v7.0.0-beta.2 release
This commit is contained in:
1 parent
6595fd0eb5
commit
fa8eba7a0d
1165 files changed
+107118
-762127
No files matched your search
@@ -648,7 +648,7 @@ export class TemplateApp {
|
||||
});
|
||||
|
||||
// setGlobalState 함수 주입
|
||||
actionDispatcher.setGlobalStateUpdater((updates: any) => this.setGlobalState(updates));
|
||||
actionDispatcher.setGlobalStateUpdater((updates: any, opts?: { render?: boolean }) => this.setGlobalState(updates, opts));
|
||||
|
||||
logger.log('Navigate function and setGlobalState injected to ActionDispatcher');
|
||||
}
|
||||
@@ -880,14 +880,29 @@ export class TemplateApp {
|
||||
const blockingSources = dataSources.filter(
|
||||
(source: any) => source.loading_strategy === 'blocking'
|
||||
);
|
||||
// WebSocket 소스는 이벤트 리스너(실시간 알림)이지 데이터 제공자가 아님
|
||||
// Step 6에서 별도로 구독 처리되므로 progressive 목록에서 제외
|
||||
// 포함 시 progressiveDataInit에서 undefined로 초기화되어 blur_until_loaded가 영구 블러됨
|
||||
const progressiveAndBackgroundSources = dataSources.filter(
|
||||
(source: any) => (source.loading_strategy || 'progressive') !== 'blocking'
|
||||
(source: any) => (source.loading_strategy || 'progressive') !== 'blocking' && source.type !== 'websocket'
|
||||
);
|
||||
|
||||
// 2.5 transition 오버레이: blocking 데이터 fetch 전에 표시 (@since engine-v1.24.0)
|
||||
// blocking 데이터 로딩 대기 시간에 skeleton/spinner UI를 보여줌
|
||||
// 2.5 transition 오버레이: blocking 데이터 fetch 전 또는 wait_for 명시 시 표시 (@since engine-v1.24.0, wait_for engine-v1.30.0)
|
||||
// blocking 데이터 로딩 대기 시간 또는 progressive 데이터 fetch 완료까지 skeleton/spinner UI 표시
|
||||
// 3단계 타겟팅: target → fallback_target → fullpage (@since engine-v1.24.2)
|
||||
if (blockingSources.length > 0 && layoutData.transition_overlay) {
|
||||
//
|
||||
// wait_for: progressive 데이터소스를 명시적으로 spinner 가드 대상으로 등록
|
||||
// - background/websocket 데이터소스는 의도상 사용자 차단 불가 → 자동 무시
|
||||
// - 존재하지 않는 ID 도 자동 무시 (검증은 백엔드 UpdateLayoutContentRequest 에서 수행)
|
||||
const waitForIds: string[] = Array.isArray((layoutData.transition_overlay as any)?.wait_for)
|
||||
? ((layoutData.transition_overlay as any).wait_for as string[])
|
||||
: [];
|
||||
const waitForActive = waitForIds.length > 0 && dataSources.some((source: any) =>
|
||||
waitForIds.includes(source.id)
|
||||
&& source.type !== 'websocket'
|
||||
&& (source.loading_strategy || 'progressive') !== 'background'
|
||||
);
|
||||
if ((blockingSources.length > 0 || waitForActive) && layoutData.transition_overlay) {
|
||||
const overlayConfig: any = typeof layoutData.transition_overlay === 'boolean'
|
||||
? { enabled: layoutData.transition_overlay, style: 'opaque' }
|
||||
: layoutData.transition_overlay;
|
||||
@@ -1203,49 +1218,7 @@ export class TemplateApp {
|
||||
// 새 DOM의 타겟에 spinner를 재생성 (@since engine-v1.29.0)
|
||||
this.reattachSpinnerOverlay();
|
||||
|
||||
// 6. WebSocket 데이터 소스 구독 (실시간 업데이트용)
|
||||
const webSocketSources = dataSources.filter((s: any) => s.type === 'websocket');
|
||||
if (webSocketSources.length > 0) {
|
||||
logger.log('Subscribing WebSocket data sources:', webSocketSources.map((s: any) => s.id));
|
||||
|
||||
const { updateTemplateData: wsUpdateData, getState: wsGetState } = await import('./template-engine');
|
||||
|
||||
this.currentWebSocketSubscriptions = dataSourceManager.subscribeWebSockets(
|
||||
dataSources,
|
||||
(sourceId: string, data: unknown) => {
|
||||
// WebSocket에서 데이터 수신 시 템플릿 업데이트
|
||||
logger.log(`WebSocket data received for: ${sourceId}`, data);
|
||||
|
||||
// fetch된 데이터 업데이트
|
||||
this.currentFetchedData[sourceId] = data;
|
||||
|
||||
// 타겟 데이터 소스 정의 찾기 (initGlobal/initLocal 캐시 무효화용)
|
||||
const targetSource = dataSources.find((s: any) => s.id === sourceId);
|
||||
|
||||
// 캐시 무효화
|
||||
const state = wsGetState();
|
||||
if (state.bindingEngine) {
|
||||
const keysToInvalidate = [sourceId];
|
||||
// 타겟 데이터 소스에 initGlobal이 있으면 _global 키도 무효화
|
||||
if (targetSource?.initGlobal) {
|
||||
keysToInvalidate.push('_global');
|
||||
}
|
||||
// 타겟 데이터 소스에 initLocal이 있으면 _local 키도 무효화
|
||||
if (targetSource?.initLocal) {
|
||||
keysToInvalidate.push('_local');
|
||||
}
|
||||
state.bindingEngine.invalidateCacheByKeys(keysToInvalidate);
|
||||
}
|
||||
|
||||
// 템플릿 업데이트
|
||||
wsUpdateData({ [sourceId]: data });
|
||||
}
|
||||
);
|
||||
|
||||
logger.log('WebSocket subscriptions established:', this.currentWebSocketSubscriptions);
|
||||
}
|
||||
|
||||
// 7. progressive + background 데이터 소스 fetch (렌더링 후)
|
||||
// 6. progressive + background 데이터 소스 fetch (렌더링 후)
|
||||
if (progressiveAndBackgroundSources.length > 0) {
|
||||
// 새 요청이 들어왔으면 현재 요청 무시 (progressive fetch 전)
|
||||
if (routeChangeId !== this.currentRouteChangeId) {
|
||||
@@ -1373,6 +1346,101 @@ export class TemplateApp {
|
||||
this.hideTransitionOverlay();
|
||||
}
|
||||
|
||||
// 7. WebSocket 데이터 소스 구독 (실시간 업데이트용)
|
||||
// progressive fetch 완료 후 구독: channel/event 표현식이 fetched 데이터(current_user 등) 참조 가능
|
||||
const webSocketSources = dataSources.filter((s: any) => s.type === 'websocket');
|
||||
if (webSocketSources.length > 0) {
|
||||
logger.log('Subscribing WebSocket data sources:', webSocketSources.map((s: any) => s.id));
|
||||
|
||||
const { updateTemplateData: wsUpdateData, getState: wsGetState } = await import('./template-engine');
|
||||
|
||||
// 채널/이벤트 표현식 평가 컨텍스트
|
||||
// blocking + progressive 데이터 모두 포함 (표현식이 fetched 데이터 참조 가능)
|
||||
const wsBindingContext = {
|
||||
...this.currentFetchedData,
|
||||
...route.params,
|
||||
route: { ...(route.params || {}), path: route.path },
|
||||
query: queryObject,
|
||||
_global: { ...this.globalState },
|
||||
};
|
||||
|
||||
// 디버깅: WebSocket 구독 직전 컨텍스트 키 로깅
|
||||
// 표현식 평가 실패 시 어떤 키가 누락되었는지 확인용
|
||||
logger.log('WebSocket binding context keys:', Object.keys(wsBindingContext));
|
||||
|
||||
this.currentWebSocketSubscriptions = dataSourceManager.subscribeWebSockets(
|
||||
dataSources,
|
||||
(sourceId: string, data: unknown) => {
|
||||
// WebSocket에서 데이터 수신 시 템플릿 업데이트
|
||||
logger.log(`WebSocket data received for: ${sourceId}`, data);
|
||||
|
||||
// fetch된 데이터 업데이트
|
||||
this.currentFetchedData[sourceId] = data;
|
||||
|
||||
// 타겟 데이터 소스 정의 찾기 (initGlobal/initLocal 캐시 무효화용)
|
||||
const targetSource = dataSources.find((s: any) => s.id === sourceId);
|
||||
|
||||
// 캐시 무효화
|
||||
const state = wsGetState();
|
||||
if (state.bindingEngine) {
|
||||
const keysToInvalidate = [sourceId];
|
||||
// 타겟 데이터 소스에 initGlobal이 있으면 _global 키도 무효화
|
||||
if (targetSource?.initGlobal) {
|
||||
keysToInvalidate.push('_global');
|
||||
}
|
||||
// 타겟 데이터 소스에 initLocal이 있으면 _local 키도 무효화
|
||||
if (targetSource?.initLocal) {
|
||||
keysToInvalidate.push('_local');
|
||||
}
|
||||
state.bindingEngine.invalidateCacheByKeys(keysToInvalidate);
|
||||
}
|
||||
|
||||
// 템플릿 업데이트
|
||||
wsUpdateData({ [sourceId]: data });
|
||||
|
||||
// engine-v1.33.0: WebSocket 데이터 소스의 onReceive 액션 실행
|
||||
// websocket 소스 정의(원본)에서 onReceive 배열을 찾음
|
||||
// sourceId는 target_source가 적용된 ID이므로 원본 websocket 소스를 별도로 찾음
|
||||
const websocketSource = dataSources.find(
|
||||
(s: any) => s.type === 'websocket' && (s.target_source || s.id) === sourceId
|
||||
);
|
||||
const onReceiveActions = websocketSource?.onReceive;
|
||||
if (Array.isArray(onReceiveActions) && onReceiveActions.length > 0) {
|
||||
const G7Core = (window as any).G7Core;
|
||||
if (G7Core?.dispatch) {
|
||||
// 각 액션을 순차 실행, $args[0]로 페이로드 접근 가능
|
||||
(async () => {
|
||||
for (const action of onReceiveActions) {
|
||||
try {
|
||||
// dispatchAction에 직접 호출하여 $args 컨텍스트 주입
|
||||
const actionDispatcher = this.getActionDispatcher?.();
|
||||
if (actionDispatcher) {
|
||||
await actionDispatcher.dispatchAction(action, {
|
||||
navigate: this.getRouter?.() ? (path: string, opts?: any) =>
|
||||
this.getRouter().navigate(path, opts) : undefined,
|
||||
setState: (updates: any) => this.setGlobalState(updates),
|
||||
state: this.globalState,
|
||||
data: { ...this.globalState, $args: [data], $event: data },
|
||||
_isDispatchFallbackContext: true,
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
logger.error(
|
||||
`WebSocket onReceive action failed for ${sourceId}:`,
|
||||
err
|
||||
);
|
||||
}
|
||||
}
|
||||
})();
|
||||
}
|
||||
}
|
||||
},
|
||||
wsBindingContext
|
||||
);
|
||||
|
||||
logger.log('WebSocket subscriptions established:', this.currentWebSocketSubscriptions);
|
||||
}
|
||||
|
||||
logger.log('Layout rendered successfully');
|
||||
} catch (error) {
|
||||
logger.error('Route change handling failed:', error);
|
||||
@@ -2567,6 +2635,97 @@ export class TemplateApp {
|
||||
return this.layoutLoader;
|
||||
}
|
||||
|
||||
/**
|
||||
* 확장 상태(routes/translations/layouts/module assets) 원자적 재동기화
|
||||
*
|
||||
* 모듈/플러그인/템플릿의 install/activate/deactivate/uninstall 직후 호출되어
|
||||
* 전체 새로고침 없이 변경된 확장 상태를 즉시 반영합니다.
|
||||
*
|
||||
* 동작 순서:
|
||||
* 1. `/api/templates/{id}/config.json` 에서 최신 cache_version 획득
|
||||
* 2. 변경이 있으면 `this.extensionCacheVersion` 및 localStorage 갱신
|
||||
* 3. `router.loadRoutes(newVersion)` — 새 버전 쿼리로 routes 재fetch
|
||||
* 4. LayoutLoader.setCacheVersion + clear — 다음 레이아웃 로드부터 신 버전 사용
|
||||
* 5. TranslationEngine.setCacheVersion + loadTranslations(true) — 다국어 재로드
|
||||
*
|
||||
* 각 단계는 try/catch 로 격리되어 한 단계의 실패가 다른 단계를 막지 않습니다.
|
||||
*
|
||||
* @since engine-v1.19.0
|
||||
*/
|
||||
async reloadExtensionState(): Promise<void> {
|
||||
logger.log('reloadExtensionState: start');
|
||||
|
||||
// 1. 최신 cache_version 획득 (브라우저 캐시 우회용 `_` 쿼리 포함)
|
||||
let newVersion: number | undefined;
|
||||
try {
|
||||
const configResponse = await fetch(
|
||||
`/api/templates/${this.config.templateId}/config.json?_=${Date.now()}`
|
||||
);
|
||||
if (configResponse.ok) {
|
||||
const configResult = await configResponse.json();
|
||||
if (configResult?.success && configResult?.data?.cache_version !== undefined) {
|
||||
newVersion = configResult.data.cache_version;
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
logger.warn('reloadExtensionState: failed to fetch config.json', error);
|
||||
}
|
||||
|
||||
// 2. 버전 상태 갱신
|
||||
if (newVersion !== undefined && newVersion !== this.extensionCacheVersion) {
|
||||
logger.log(
|
||||
`reloadExtensionState: cache version ${this.extensionCacheVersion} -> ${newVersion}`
|
||||
);
|
||||
this.extensionCacheVersion = newVersion;
|
||||
this.saveCacheVersionToStorage(newVersion);
|
||||
}
|
||||
|
||||
// 3. Router routes 재로드 (버전 쿼리 부착 필수)
|
||||
try {
|
||||
if (this.router) {
|
||||
await this.router.loadRoutes(this.extensionCacheVersion);
|
||||
logger.log('reloadExtensionState: routes reloaded');
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensionState: routes reload failed', error);
|
||||
}
|
||||
|
||||
// 4. LayoutLoader 버전 갱신 + 캐시 클리어
|
||||
try {
|
||||
if (this.layoutLoader) {
|
||||
if (this.extensionCacheVersion > 0) {
|
||||
this.layoutLoader.setCacheVersion(this.extensionCacheVersion);
|
||||
}
|
||||
this.layoutLoader.clear();
|
||||
logger.log('reloadExtensionState: layout cache cleared');
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensionState: layout cache clear failed', error);
|
||||
}
|
||||
|
||||
// 5. 다국어 재로드 — 활성 translations 맵은 loadTranslations 가 원자적으로 교체할 때까지
|
||||
// 유지되므로 병렬 `toast($t:...)` 와 경합하지 않음. 명시적 clearCache() 호출 금지
|
||||
// (engine-v1.38.1 참고: setCacheVersion 이 TTL 캐시만 비움).
|
||||
try {
|
||||
const { TranslationEngine } = await import('./template-engine/TranslationEngine');
|
||||
const translationEngine = TranslationEngine.getInstance();
|
||||
if (this.extensionCacheVersion > 0) {
|
||||
translationEngine.setCacheVersion(this.extensionCacheVersion);
|
||||
}
|
||||
const locale = this.config.locale || 'ko';
|
||||
const fallbackLocale = 'en';
|
||||
await translationEngine.loadTranslations(this.config.templateId, locale, '/api', true);
|
||||
if (locale !== fallbackLocale) {
|
||||
await translationEngine.loadTranslations(this.config.templateId, fallbackLocale, '/api', true);
|
||||
}
|
||||
logger.log('reloadExtensionState: translations reloaded');
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensionState: translations reload failed', error);
|
||||
}
|
||||
|
||||
logger.log('reloadExtensionState: done');
|
||||
}
|
||||
|
||||
/**
|
||||
* ActionDispatcher 인스턴스 반환
|
||||
*
|
||||
@@ -2638,7 +2797,7 @@ export class TemplateApp {
|
||||
navigate: (path: string) => this.router?.navigate(path),
|
||||
});
|
||||
|
||||
actionDispatcher.setGlobalStateUpdater((updates: any) => this.setGlobalState(updates));
|
||||
actionDispatcher.setGlobalStateUpdater((updates: any, opts?: { render?: boolean }) => this.setGlobalState(updates, opts));
|
||||
|
||||
logger.log('Navigate function and setGlobalState re-injected to ActionDispatcher');
|
||||
}
|
||||
@@ -2916,11 +3075,11 @@ export class TemplateApp {
|
||||
* 전역 상태 업데이트
|
||||
*
|
||||
* @param updates 업데이트할 상태 객체 또는 함수형 업데이트 (prev => newState)
|
||||
* @param options.render false이면 상태 업데이트만 수행하고 React 렌더링을 건너뜀 (engine-v1.42.0+)
|
||||
*/
|
||||
setGlobalState(updates: Partial<GlobalState> | ((prev: GlobalState) => GlobalState)): void {
|
||||
setGlobalState(updates: Partial<GlobalState> | ((prev: GlobalState) => GlobalState), options?: { render?: boolean }): void {
|
||||
// DevTools: 이전 상태 저장
|
||||
const prevState = { ...this.globalState };
|
||||
|
||||
// 함수형 업데이트 지원 (Form dataKey="_global.xxx" 자동 바인딩에서 사용)
|
||||
if (typeof updates === 'function') {
|
||||
this.globalState = updates(this.globalState);
|
||||
@@ -2946,6 +3105,11 @@ export class TemplateApp {
|
||||
listener(this.globalState);
|
||||
});
|
||||
|
||||
// engine-v1.42.0: render: false이면 상태 업데이트만 수행, React 렌더링 건너뛰기
|
||||
// 값은 this.globalState에 저장되므로 getLocal()/getState()로 최신 값 접근 가능
|
||||
// 플러그인(CKEditor 등)이 자체 DOM을 관리하는 경우, React 리렌더 없이 값만 저장
|
||||
if (options?.render === false) return;
|
||||
|
||||
// 전역 상태만 업데이트 (라우트 재로딩 없이)
|
||||
// 렌더링 완료 여부 확인 후 updateTemplateData 호출
|
||||
// init_actions에서 setGlobalState가 호출될 때는 아직 renderTemplate 전이므로
|
||||
@@ -3447,13 +3611,18 @@ export class TemplateApp {
|
||||
* navigate 핸들러에서 replace: true 옵션 사용 시 자동 호출됩니다.
|
||||
*
|
||||
* @param newPath 새 경로 (쿼리스트링 포함)
|
||||
* @param options 선택 옵션
|
||||
* - transitionOverlayTarget: 이 호출에 한해 transition_overlay.target 을 동적으로 override
|
||||
* (탭 안의 서브 탭, 목록 페이지네이션 등 부분 영역만 spinner 가 표시되어야 할 때 사용)
|
||||
* @since engine-v1.36.0
|
||||
* @returns refetch 완료 후 resolve되는 Promise
|
||||
*
|
||||
* @example
|
||||
* // ActionDispatcher에서 호출
|
||||
* G7Core.updateQueryParams('/admin/products?status=active&page=2');
|
||||
* G7Core.updateQueryParams('/admin/settings?tab=notification&channel=email', { transitionOverlayTarget: 'notif_channel_content' });
|
||||
*/
|
||||
async updateQueryParams(newPath: string): Promise<void> {
|
||||
async updateQueryParams(newPath: string, options?: { transitionOverlayTarget?: string }): Promise<void> {
|
||||
logger.log('updateQueryParams:', newPath);
|
||||
|
||||
// URL 파싱
|
||||
@@ -3469,8 +3638,10 @@ export class TemplateApp {
|
||||
logger.log('currentQueryParams updated:', Object.fromEntries(newQueryParams.entries()));
|
||||
|
||||
// 3. auto_fetch: true인 데이터 소스들 refetch
|
||||
// WebSocket 소스는 이벤트 리스너(실시간 알림)이지 fetch 대상이 아님 (engine-v1.32.2 정책)
|
||||
// handleRouteChange progressive 경로와 동일하게 호출 전에 필터링하여 계약 일관성 확보
|
||||
const autoFetchDataSources = this.currentDataSources.filter(
|
||||
(ds: any) => ds.auto_fetch !== false
|
||||
(ds: any) => ds.auto_fetch !== false && ds.type !== 'websocket'
|
||||
);
|
||||
|
||||
if (autoFetchDataSources.length === 0) {
|
||||
@@ -3483,6 +3654,27 @@ export class TemplateApp {
|
||||
// blur_until_loaded 지원: transition 상태를 pending으로 설정
|
||||
transitionManager.setPending(true);
|
||||
|
||||
// transition_overlay spinner: wait_for 에 명시된 progressive 데이터소스가 refetch 대상이면 오버레이 표시
|
||||
// navigate replace:true(탭 전환 등)로 이 경로에 진입했을 때 handleRouteChange step 2.5 와 동일 동작 (@since engine-v1.35.0)
|
||||
// options.transitionOverlayTarget 으로 호출별 target 동적 override 지원 (탭 안의 서브 탭/페이지네이션 등) (@since engine-v1.36.0)
|
||||
const layoutJson = getState().currentLayoutJson as any;
|
||||
const overlayConfig = layoutJson?.transition_overlay;
|
||||
const waitForIds: string[] = Array.isArray(overlayConfig?.wait_for) ? overlayConfig.wait_for : [];
|
||||
const blockingRefetch = autoFetchDataSources.some((s: any) => (s.loading_strategy || 'progressive') === 'blocking');
|
||||
const waitForActive = waitForIds.length > 0 && autoFetchDataSources.some((s: any) =>
|
||||
waitForIds.includes(s.id)
|
||||
&& s.type !== 'websocket'
|
||||
&& (s.loading_strategy || 'progressive') !== 'background'
|
||||
);
|
||||
if ((blockingRefetch || waitForActive) && overlayConfig && typeof overlayConfig === 'object') {
|
||||
const effectiveTarget = options?.transitionOverlayTarget || overlayConfig.target;
|
||||
if (overlayConfig.enabled && overlayConfig.style === 'skeleton' && overlayConfig.skeleton?.component && effectiveTarget) {
|
||||
this.renderSkeletonOverlay(effectiveTarget, overlayConfig.skeleton, layoutJson, overlayConfig.fallback_target);
|
||||
} else if (overlayConfig.enabled && overlayConfig.style === 'spinner' && effectiveTarget) {
|
||||
this.renderSpinnerOverlay(effectiveTarget, overlayConfig.spinner, overlayConfig.fallback_target);
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const dataSourceManager = new DataSourceManager();
|
||||
|
||||
@@ -3506,13 +3698,20 @@ export class TemplateApp {
|
||||
);
|
||||
|
||||
// 결과 처리 및 UI 업데이트
|
||||
// result.id 기반 조회로 매핑 (handleRouteChange blocking 경로와 동일 패턴)
|
||||
// 인덱스 기반 매핑은 fetchDataSourcesWithResults가 내부에서 소스를 필터링할 경우
|
||||
// autoFetchDataSources와 results의 인덱스가 어긋나 데이터가 잘못된 키에 기록됨
|
||||
const updateData: Record<string, any> = {};
|
||||
const localInit: Record<string, any> = {};
|
||||
const sourceById = new Map(autoFetchDataSources.map((ds: any) => [ds.id, ds]));
|
||||
|
||||
for (let i = 0; i < results.length; i++) {
|
||||
const result = results[i];
|
||||
const dataSourceDef = autoFetchDataSources[i];
|
||||
const dataSourceId = dataSourceDef.id;
|
||||
for (const result of results) {
|
||||
const dataSourceDef = sourceById.get(result.id);
|
||||
if (!dataSourceDef) {
|
||||
logger.warn(`Refetch result id not found in autoFetchDataSources: ${result.id}`);
|
||||
continue;
|
||||
}
|
||||
const dataSourceId = result.id;
|
||||
|
||||
if (result.state === 'success' && result.data !== undefined) {
|
||||
// 캐시 업데이트
|
||||
@@ -3571,6 +3770,8 @@ export class TemplateApp {
|
||||
} finally {
|
||||
// transition 상태 해제
|
||||
transitionManager.setPending(false);
|
||||
// transition_overlay spinner 해제 (@since engine-v1.35.0)
|
||||
this.hideTransitionOverlay();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1599,4 +1599,352 @@ describe('TemplateApp', () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// =============================================================================
|
||||
// 회귀 테스트: WebSocket 데이터소스 progressive 제외 (engine-v1.32.2)
|
||||
// 이슈: WebSocket 소스가 progressiveDataInit에서 undefined로 초기화되어
|
||||
// blur_until_loaded가 영구 블러 → WebSocket 성공/실패 무관하게 발생
|
||||
// =============================================================================
|
||||
describe('Regression Tests - WebSocket Source Filtering', () => {
|
||||
/**
|
||||
* [TS-WS-PROGRESSIVE-1] WebSocket 소스는 progressive 목록에서 제외
|
||||
*
|
||||
* WebSocket은 이벤트 리스너이지 데이터 제공자가 아니므로
|
||||
* progressiveDataInit에 포함되면 dataContext에 undefined 키가 영구 잔존하고
|
||||
* blur_until_loaded가 절대 해제되지 않음
|
||||
*/
|
||||
describe('[TS-WS-PROGRESSIVE-1] WebSocket 소스 progressive 필터 제외', () => {
|
||||
it('WebSocket 타입 소스는 progressiveAndBackgroundSources에 포함되지 않아야 함', () => {
|
||||
const dataSources = [
|
||||
{ id: 'users', type: 'api', endpoint: '/api/users' },
|
||||
{ id: 'modules', type: 'api', endpoint: '/api/modules', loading_strategy: 'progressive' },
|
||||
{ id: 'config', type: 'api', endpoint: '/api/config', loading_strategy: 'blocking' },
|
||||
{
|
||||
id: 'notification_ws',
|
||||
type: 'websocket',
|
||||
channel: 'core.user.notifications.1',
|
||||
event: 'notification.received',
|
||||
target_source: 'notification_unread_count',
|
||||
},
|
||||
];
|
||||
|
||||
// TemplateApp.ts의 progressive 필터 로직 (engine-v1.32.2)
|
||||
const progressiveAndBackgroundSources = dataSources.filter(
|
||||
(source: any) =>
|
||||
(source.loading_strategy || 'progressive') !== 'blocking' &&
|
||||
source.type !== 'websocket'
|
||||
);
|
||||
|
||||
const ids = progressiveAndBackgroundSources.map((s) => s.id);
|
||||
|
||||
// API progressive 소스만 포함
|
||||
expect(ids).toContain('users');
|
||||
expect(ids).toContain('modules');
|
||||
// blocking 제외
|
||||
expect(ids).not.toContain('config');
|
||||
// WebSocket 제외 (핵심)
|
||||
expect(ids).not.toContain('notification_ws');
|
||||
});
|
||||
|
||||
it('WebSocket 소스는 progressiveDataInit에서 undefined 초기화되지 않아야 함', () => {
|
||||
const dataSources = [
|
||||
{ id: 'users', type: 'api', endpoint: '/api/users' },
|
||||
{
|
||||
id: 'notification_ws',
|
||||
type: 'websocket',
|
||||
channel: 'core.user.notifications.1',
|
||||
event: 'notification.received',
|
||||
},
|
||||
];
|
||||
|
||||
const progressiveAndBackgroundSources = dataSources.filter(
|
||||
(source: any) =>
|
||||
(source.loading_strategy || 'progressive') !== 'blocking' &&
|
||||
source.type !== 'websocket'
|
||||
);
|
||||
const progressiveDataSourceIds = progressiveAndBackgroundSources.map((s: any) => s.id);
|
||||
|
||||
const progressiveDataInit: Record<string, any> = {};
|
||||
progressiveDataSourceIds.forEach((id: string) => {
|
||||
progressiveDataInit[id] = undefined;
|
||||
});
|
||||
|
||||
// dataContext에 WebSocket 키가 존재하지 않아야 함 (blur_until_loaded 회귀 방지)
|
||||
expect('notification_ws' in progressiveDataInit).toBe(false);
|
||||
expect('users' in progressiveDataInit).toBe(true);
|
||||
});
|
||||
|
||||
it('blur_until_loaded: true 체크 시 WebSocket 키가 dataContext에 없어야 영구 블러 방지', () => {
|
||||
// blur_until_loaded: true의 체크 로직 시뮬레이션 (DynamicRenderer.tsx)
|
||||
const systemKeys = ['route', 'query', '_global', '_local', '_dataSourceErrors'];
|
||||
|
||||
// 수정 전: WebSocket 소스가 progressive에 포함되어 dataContext에 undefined로 존재
|
||||
const dataContextBefore = {
|
||||
users: { data: [{ id: 1 }] },
|
||||
modules: { data: [{ id: 'mod-1' }] },
|
||||
notification_ws: undefined, // ← 영구 undefined (블러 영구 유지)
|
||||
route: {},
|
||||
query: {},
|
||||
_global: {},
|
||||
};
|
||||
const keysBefore = Object.keys(dataContextBefore).filter(
|
||||
(key) => !systemKeys.includes(key) && !key.startsWith('_')
|
||||
);
|
||||
const hasUndefinedBefore = keysBefore.some(
|
||||
(key) => (dataContextBefore as any)[key] === undefined
|
||||
);
|
||||
expect(hasUndefinedBefore).toBe(true); // 버그 재현: 영구 블러
|
||||
|
||||
// 수정 후: WebSocket 소스가 dataContext에 아예 존재하지 않음
|
||||
const dataContextAfter = {
|
||||
users: { data: [{ id: 1 }] },
|
||||
modules: { data: [{ id: 'mod-1' }] },
|
||||
route: {},
|
||||
query: {},
|
||||
_global: {},
|
||||
};
|
||||
const keysAfter = Object.keys(dataContextAfter).filter(
|
||||
(key) => !systemKeys.includes(key) && !key.startsWith('_')
|
||||
);
|
||||
const hasUndefinedAfter = keysAfter.some(
|
||||
(key) => (dataContextAfter as any)[key] === undefined
|
||||
);
|
||||
expect(hasUndefinedAfter).toBe(false); // 수정 검증: 블러 정상 해제
|
||||
});
|
||||
|
||||
it('WebSocket 소스는 target_source로 다른 데이터소스를 트리거하지만 자체 데이터를 제공하지 않음', () => {
|
||||
// notification_ws는 콜백에서 source.target_source || source.id 사용 (DataSourceManager.subscribeWebSockets)
|
||||
// → 콜백이 호출되어도 dataContext에 'notification_ws' 키는 절대 추가되지 않음
|
||||
// → progressiveDataInit에 포함되어선 안 되는 명백한 근거
|
||||
const wsSource = {
|
||||
id: 'notification_ws',
|
||||
type: 'websocket',
|
||||
target_source: 'notification_unread_count',
|
||||
};
|
||||
|
||||
const targetId = wsSource.target_source || wsSource.id;
|
||||
expect(targetId).toBe('notification_unread_count');
|
||||
expect(targetId).not.toBe('notification_ws');
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* [TS-WS-CHANNEL-EXPR-1] WebSocket channel/event 표현식 평가 (engine-v1.32.3)
|
||||
*
|
||||
* 채널명에 표현식이 포함된 경우(예: core.user.notifications.{{current_user.data.id}}),
|
||||
* 평가 없이 그대로 구독하면 백엔드 채널 패턴과 매칭되지 않아 broadcasting/auth가
|
||||
* AccessDeniedHttpException을 던짐. fetched 데이터를 컨텍스트로 삼아 평가해야 함.
|
||||
*/
|
||||
describe('[TS-WS-CHANNEL-EXPR-1] WebSocket channel/event 표현식 평가', () => {
|
||||
it('표현식이 포함된 채널명은 fetched 데이터로 평가되어야 함', () => {
|
||||
const fetchedData = {
|
||||
current_user: { data: { id: 42, username: 'admin' } },
|
||||
};
|
||||
const source = {
|
||||
id: 'notification_ws',
|
||||
type: 'websocket',
|
||||
channel: 'core.user.notifications.{{current_user.data.id}}',
|
||||
event: 'notification.received',
|
||||
};
|
||||
|
||||
// resolveExpressionString 동작 시뮬레이션
|
||||
const channelTemplate = source.channel;
|
||||
const resolved = channelTemplate.replace(
|
||||
/\{\{([^}]+)\}\}/g,
|
||||
(_match: string, expr: string) => {
|
||||
const path = expr.trim().split('.');
|
||||
let value: any = fetchedData;
|
||||
for (const key of path) {
|
||||
value = value?.[key];
|
||||
}
|
||||
return value !== undefined ? String(value) : '';
|
||||
}
|
||||
);
|
||||
|
||||
expect(resolved).toBe('core.user.notifications.42');
|
||||
expect(resolved).not.toContain('{{');
|
||||
});
|
||||
|
||||
it('정적 채널은 표현식 평가 후에도 동일해야 함', () => {
|
||||
const source = {
|
||||
channel: 'core.admin.dashboard',
|
||||
event: 'dashboard.stats.updated',
|
||||
};
|
||||
|
||||
// 정적 채널은 평가해도 변경 없음 (표현식 마커 없음)
|
||||
expect(source.channel.includes('{{')).toBe(false);
|
||||
expect(source.event.includes('{{')).toBe(false);
|
||||
});
|
||||
|
||||
it('미평가 표현식이 남아있으면 구독을 건너뛰어야 함 (방어 로직)', () => {
|
||||
// current_user가 아직 로드되지 않은 상태에서 평가 시도하면
|
||||
// 표현식 마커가 남아있을 수 있음 → 구독 건너뜀
|
||||
const fetchedData: Record<string, any> = {}; // current_user 없음
|
||||
const channelTemplate = 'core.user.notifications.{{current_user.data.id}}';
|
||||
|
||||
const resolved = channelTemplate.replace(
|
||||
/\{\{([^}]+)\}\}/g,
|
||||
(_match: string, expr: string) => {
|
||||
const path = expr.trim().split('.');
|
||||
let value: any = fetchedData;
|
||||
for (const key of path) {
|
||||
value = value?.[key];
|
||||
}
|
||||
return value !== undefined ? String(value) : `{{${expr}}}`;
|
||||
}
|
||||
);
|
||||
|
||||
// 표현식이 평가되지 못했음
|
||||
expect(resolved.includes('{{') || resolved.endsWith('.')).toBe(true);
|
||||
|
||||
// 이런 경우 구독을 건너뛰어야 함 (DataSourceManager.subscribeWebSockets 방어 로직)
|
||||
const shouldSkipSubscription = resolved.includes('{{');
|
||||
// 빈 문자열로 치환된 경우는 trailing dot으로 감지
|
||||
const isInvalidChannel = shouldSkipSubscription || /\.$/.test(resolved);
|
||||
expect(isInvalidChannel).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* [TS-WS-ORDER-1] WebSocket 구독 순서 (engine-v1.32.3)
|
||||
*
|
||||
* WebSocket 구독은 progressive fetch 완료 후에 실행되어야 함.
|
||||
* 채널 표현식이 progressive 데이터(current_user 등)를 참조할 수 있기 때문.
|
||||
*/
|
||||
describe('[TS-WS-ORDER-1] WebSocket 구독 순서', () => {
|
||||
it('WebSocket 구독은 progressive fetch 완료 후에 실행되어야 함', () => {
|
||||
const executionLog: string[] = [];
|
||||
|
||||
// 시뮬레이션: blocking → render → progressive → websocket
|
||||
executionLog.push('blocking_fetched');
|
||||
executionLog.push('rendered');
|
||||
executionLog.push('progressive_fetched');
|
||||
executionLog.push('websocket_subscribed');
|
||||
|
||||
const renderIndex = executionLog.indexOf('rendered');
|
||||
const progressiveIndex = executionLog.indexOf('progressive_fetched');
|
||||
const websocketIndex = executionLog.indexOf('websocket_subscribed');
|
||||
|
||||
// render 후에 progressive fetch
|
||||
expect(progressiveIndex).toBeGreaterThan(renderIndex);
|
||||
// progressive fetch 후에 websocket 구독 (current_user 등 참조 위해)
|
||||
expect(websocketIndex).toBeGreaterThan(progressiveIndex);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* [TS-UQP-INDEX-1] updateQueryParams 데이터소스 refetch id 기반 매핑 (engine-v1.32.5)
|
||||
*
|
||||
* 이슈: navigate(replace:true) 시 updateQueryParams가 autoFetchDataSources[i]로
|
||||
* 인덱스 매핑하면 fetchDataSourcesWithResults 내부 WebSocket silent filter로
|
||||
* 인해 results가 짧아져 인덱스 어긋남 발생. settings 데이터가 notification_ws
|
||||
* 키에 기록되고, form initLocal이 다른 데이터소스 응답으로 초기화되어 탭 콘텐츠 빈 화면.
|
||||
*
|
||||
* 수정: id 기반 Map 조회 + WebSocket 사전 필터링 (handleRouteChange 패턴과 통일)
|
||||
*/
|
||||
describe('[TS-UQP-INDEX-1] updateQueryParams id 기반 매핑', () => {
|
||||
it('WebSocket 소스가 중간에 있어도 results와 autoFetchDataSources 매핑이 어긋나지 않아야 함', () => {
|
||||
// 시뮬레이션: _admin_base.json (WebSocket 포함) + admin_settings.json 결합 데이터소스
|
||||
const autoFetchDataSources = [
|
||||
{ id: 'notifications', type: 'api' },
|
||||
{ id: 'notification_unread_count', type: 'api' },
|
||||
{ id: 'installed_modules', type: 'api' },
|
||||
{ id: 'installed_plugins', type: 'api' },
|
||||
{ id: 'notification_ws', type: 'websocket' }, // ← 중간에 WebSocket
|
||||
{ id: 'settings', type: 'api', initLocal: { form: '{{data}}' } },
|
||||
{ id: 'systemInfo', type: 'api' },
|
||||
{ id: 'appKey', type: 'api' },
|
||||
{ id: 'notificationDefinitions', type: 'api' },
|
||||
{ id: 'availableChannels', type: 'api' },
|
||||
];
|
||||
|
||||
// engine-v1.32.5 수정: 사전 WebSocket 필터링
|
||||
const filtered = autoFetchDataSources.filter(
|
||||
(ds: any) => ds.type !== 'websocket'
|
||||
);
|
||||
|
||||
// WebSocket이 제외되었는지 확인
|
||||
expect(filtered.find((s) => s.id === 'notification_ws')).toBeUndefined();
|
||||
expect(filtered).toHaveLength(9);
|
||||
|
||||
// 시뮬레이션: fetchDataSourcesWithResults가 필터된 소스만 fetch하여 id 포함 results 반환
|
||||
const results = filtered.map((s) => ({
|
||||
id: s.id,
|
||||
state: 'success' as const,
|
||||
data: { _source: s.id }, // 소스 id를 데이터에 포함시켜 매핑 검증
|
||||
}));
|
||||
|
||||
// id 기반 Map 조회 (engine-v1.32.5 수정 패턴)
|
||||
const sourceById = new Map(filtered.map((ds: any) => [ds.id, ds]));
|
||||
const updateData: Record<string, any> = {};
|
||||
|
||||
for (const result of results) {
|
||||
const dataSourceDef = sourceById.get(result.id);
|
||||
expect(dataSourceDef).toBeDefined();
|
||||
// 핵심 검증: dataSourceDef.id === result.id (어긋나지 않음)
|
||||
expect(dataSourceDef!.id).toBe(result.id);
|
||||
updateData[result.id] = result.data;
|
||||
}
|
||||
|
||||
// settings 데이터가 settings 키에 기록되었는지 (NOT notification_ws, NOT systemInfo)
|
||||
expect(updateData.settings).toEqual({ _source: 'settings' });
|
||||
expect(updateData.systemInfo).toEqual({ _source: 'systemInfo' });
|
||||
// 마지막 소스도 누락 없이 기록
|
||||
expect(updateData.availableChannels).toEqual({ _source: 'availableChannels' });
|
||||
});
|
||||
|
||||
it('인덱스 기반 매핑 (BEFORE) 은 WebSocket이 있으면 어긋남을 재현', () => {
|
||||
// 회귀 방지: 이전 버그 재현을 통해 id 기반 매핑의 필요성 증명
|
||||
const autoFetchDataSources = [
|
||||
{ id: 'api_a', type: 'api' },
|
||||
{ id: 'ws_source', type: 'websocket' },
|
||||
{ id: 'api_b', type: 'api' },
|
||||
{ id: 'api_c', type: 'api' },
|
||||
];
|
||||
|
||||
// fetchDataSourcesWithResults 내부 필터 (WebSocket 제거)
|
||||
const targetSources = autoFetchDataSources.filter(
|
||||
(s) => s.type !== 'websocket'
|
||||
);
|
||||
|
||||
const results = targetSources.map((s) => ({
|
||||
id: s.id,
|
||||
state: 'success' as const,
|
||||
data: { _source: s.id },
|
||||
}));
|
||||
|
||||
// BEFORE: 인덱스 기반 매핑 (버그)
|
||||
const buggyMapping: Record<string, any> = {};
|
||||
for (let i = 0; i < results.length; i++) {
|
||||
const result = results[i];
|
||||
const dataSourceDef = autoFetchDataSources[i]; // ← 필터 안 된 원본
|
||||
buggyMapping[dataSourceDef.id] = result.data;
|
||||
}
|
||||
|
||||
// 증명: api_b 데이터가 ws_source 키에 잘못 기록됨
|
||||
expect(buggyMapping.ws_source).toEqual({ _source: 'api_b' });
|
||||
// api_a만 정상
|
||||
expect(buggyMapping.api_a).toEqual({ _source: 'api_a' });
|
||||
// api_c는 누락됨 (results 끝에서 잘림)
|
||||
expect(buggyMapping.api_c).toBeUndefined();
|
||||
|
||||
// AFTER: id 기반 매핑 (수정)
|
||||
const sourceById = new Map(
|
||||
autoFetchDataSources.filter((ds) => ds.type !== 'websocket').map((ds) => [ds.id, ds])
|
||||
);
|
||||
const fixedMapping: Record<string, any> = {};
|
||||
for (const result of results) {
|
||||
const def = sourceById.get(result.id);
|
||||
if (def) fixedMapping[result.id] = result.data;
|
||||
}
|
||||
|
||||
// 모든 API 소스가 올바른 키에 기록됨
|
||||
expect(fixedMapping.api_a).toEqual({ _source: 'api_a' });
|
||||
expect(fixedMapping.api_b).toEqual({ _source: 'api_b' });
|
||||
expect(fixedMapping.api_c).toEqual({ _source: 'api_c' });
|
||||
// WebSocket 키는 존재하지 않음 (fetch 대상 아님)
|
||||
expect(fixedMapping.ws_source).toBeUndefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -65,7 +65,7 @@ export const CacheTab: React.FC<CacheTabProps> = ({ stats, devTools }) => {
|
||||
<div className="g7dt-stat-label">Entries</div>
|
||||
</div>
|
||||
<div className="g7dt-stat-card">
|
||||
<div className="g7dt-stat-value g7dt-text-purple">{stats.hitRate.toFixed(1)}%</div>
|
||||
<div className="g7dt-stat-value g7dt-text-purple">{(stats.hitRate * 100).toFixed(1)}%</div>
|
||||
<div className="g7dt-stat-label">Hit Rate</div>
|
||||
</div>
|
||||
</div>
|
||||
@@ -74,7 +74,7 @@ export const CacheTab: React.FC<CacheTabProps> = ({ stats, devTools }) => {
|
||||
<div className="g7dt-space-y-2">
|
||||
<div className="g7dt-text-sm g7dt-text-gray">캐시 히트율</div>
|
||||
<div className="g7dt-progress-bar">
|
||||
<div className="g7dt-progress-fill" style={{ width: `${stats.hitRate}%` }} />
|
||||
<div className="g7dt-progress-fill" style={{ width: `${stats.hitRate * 100}%` }} />
|
||||
</div>
|
||||
</div>
|
||||
|
||||
|
||||
@@ -63,8 +63,9 @@ export class ModuleAssetLoader {
|
||||
/**
|
||||
* 활성화된 모듈들의 에셋을 로드합니다.
|
||||
*
|
||||
* 우선순위 순으로 정렬하여 순차적으로 로드합니다.
|
||||
* CSS는 병렬로 로드하고, JS는 순차적으로 로드합니다.
|
||||
* CSS/JS 모두 병렬 fetch로 로드합니다. JS는 `script.async = false` +
|
||||
* 정렬된 DOM append 순서로 **실행 순서는 priority 정렬대로** 보장됩니다.
|
||||
* (HTML 사양: async=false 스크립트는 삽입 순서대로 실행)
|
||||
*
|
||||
* @param extensions 모듈 에셋 배열
|
||||
*/
|
||||
@@ -79,20 +80,18 @@ export class ModuleAssetLoader {
|
||||
|
||||
logger.log('Loading module assets:', sortedExtensions.map(e => e.identifier));
|
||||
|
||||
// CSS를 먼저 병렬로 로드 (렌더링 블로킹 방지)
|
||||
// CSS 병렬 로드 (렌더링 블로킹 방지)
|
||||
const cssPromises = sortedExtensions
|
||||
.filter(ext => ext.css)
|
||||
.map(ext => this.loadCSS(ext.identifier, ext.css!));
|
||||
|
||||
await Promise.all(cssPromises);
|
||||
logger.log('All CSS assets loaded');
|
||||
// JS 병렬 fetch (script.async=false로 실행 순서는 append 순서대로 유지)
|
||||
// 정렬된 순서로 순차 append하여 우선순위 기반 실행 순서를 보장
|
||||
const jsPromises = sortedExtensions
|
||||
.filter(ext => ext.js)
|
||||
.map(ext => this.loadJS(ext.identifier, ext.js!));
|
||||
|
||||
// JS를 순차적으로 로드 (의존성 순서 보장)
|
||||
for (const ext of sortedExtensions) {
|
||||
if (ext.js) {
|
||||
await this.loadJS(ext.identifier, ext.js);
|
||||
}
|
||||
}
|
||||
await Promise.all([...cssPromises, ...jsPromises]);
|
||||
|
||||
logger.log('All module assets loaded successfully');
|
||||
}
|
||||
|
||||
@@ -0,0 +1,168 @@
|
||||
/**
|
||||
* ModuleAssetLoader 테스트
|
||||
*
|
||||
* 확장 에셋의 병렬 fetch + 실행 순서 보장(priority 정렬) 동작을 검증합니다.
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { ModuleAssetLoader, type ModuleAsset } from '../ModuleAssetLoader';
|
||||
|
||||
describe('ModuleAssetLoader', () => {
|
||||
let loader: ModuleAssetLoader;
|
||||
let originalCreateElement: typeof document.createElement;
|
||||
|
||||
beforeEach(() => {
|
||||
loader = new ModuleAssetLoader();
|
||||
originalCreateElement = document.createElement.bind(document);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
document.head.querySelectorAll('[id^="module-js-"],[id^="module-css-"]')
|
||||
.forEach(el => el.remove());
|
||||
});
|
||||
|
||||
describe('loadActiveExtensionAssets', () => {
|
||||
it('JS 에셋을 priority 오름차순으로 DOM에 append한다 (실행 순서 보장)', async () => {
|
||||
const appendOrder: string[] = [];
|
||||
|
||||
const createElementSpy = vi.spyOn(document, 'createElement').mockImplementation((tag: string) => {
|
||||
const el = originalCreateElement(tag);
|
||||
if (tag === 'script') {
|
||||
Object.defineProperty(el, 'src', {
|
||||
set(v) {
|
||||
(el as any)._src = v;
|
||||
},
|
||||
get() {
|
||||
return (el as any)._src;
|
||||
},
|
||||
});
|
||||
}
|
||||
return el;
|
||||
});
|
||||
|
||||
const appendSpy = vi.spyOn(document.head, 'appendChild').mockImplementation(((node: any) => {
|
||||
if (node.tagName === 'SCRIPT') {
|
||||
appendOrder.push(node.id);
|
||||
// onload 즉시 호출 (fetch 완료 시뮬레이션)
|
||||
queueMicrotask(() => node.onload?.());
|
||||
} else if (node.tagName === 'LINK') {
|
||||
queueMicrotask(() => node.onload?.());
|
||||
}
|
||||
return node;
|
||||
}) as any);
|
||||
|
||||
const extensions: ModuleAsset[] = [
|
||||
{ identifier: 'ext-c', js: '/c.js', priority: 30 },
|
||||
{ identifier: 'ext-a', js: '/a.js', priority: 10 },
|
||||
{ identifier: 'ext-b', js: '/b.js', priority: 20 },
|
||||
];
|
||||
|
||||
await loader.loadActiveExtensionAssets(extensions);
|
||||
|
||||
expect(appendOrder).toEqual([
|
||||
'module-js-ext-a',
|
||||
'module-js-ext-b',
|
||||
'module-js-ext-c',
|
||||
]);
|
||||
|
||||
createElementSpy.mockRestore();
|
||||
appendSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('모든 스크립트에 async=false가 설정되어야 한다 (실행 순서 보장 계약)', async () => {
|
||||
const createdScripts: HTMLScriptElement[] = [];
|
||||
|
||||
const appendSpy = vi.spyOn(document.head, 'appendChild').mockImplementation(((node: any) => {
|
||||
if (node.tagName === 'SCRIPT') {
|
||||
createdScripts.push(node);
|
||||
queueMicrotask(() => node.onload?.());
|
||||
}
|
||||
return node;
|
||||
}) as any);
|
||||
|
||||
const extensions: ModuleAsset[] = [
|
||||
{ identifier: 'ext-1', js: '/1.js', priority: 100 },
|
||||
{ identifier: 'ext-2', js: '/2.js', priority: 100 },
|
||||
];
|
||||
|
||||
await loader.loadActiveExtensionAssets(extensions);
|
||||
|
||||
expect(createdScripts).toHaveLength(2);
|
||||
createdScripts.forEach(s => expect(s.async).toBe(false));
|
||||
|
||||
appendSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('JS 에셋 fetch를 병렬로 착수한다 (Phase 1 병렬화 회귀 방지)', async () => {
|
||||
// 첫 번째 append 시점에 아직 두 번째 append도 큐잉되어야 함
|
||||
// (순차 await 방식이면 첫 onload 이후에만 두 번째 append가 발생)
|
||||
const appendTimestamps: number[] = [];
|
||||
let firstAppendResolved = false;
|
||||
const resolvers: Array<() => void> = [];
|
||||
|
||||
const appendSpy = vi.spyOn(document.head, 'appendChild').mockImplementation(((node: any) => {
|
||||
if (node.tagName === 'SCRIPT') {
|
||||
appendTimestamps.push(performance.now());
|
||||
// onload는 수동 트리거 (모두 append 된 뒤 일괄 resolve)
|
||||
resolvers.push(() => node.onload?.());
|
||||
}
|
||||
return node;
|
||||
}) as any);
|
||||
|
||||
const extensions: ModuleAsset[] = [
|
||||
{ identifier: 'p-1', js: '/1.js', priority: 100 },
|
||||
{ identifier: 'p-2', js: '/2.js', priority: 100 },
|
||||
{ identifier: 'p-3', js: '/3.js', priority: 100 },
|
||||
];
|
||||
|
||||
const loadPromise = loader.loadActiveExtensionAssets(extensions);
|
||||
|
||||
// 마이크로태스크 1회 flush — 모든 script가 append 되어야 함
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
|
||||
expect(appendTimestamps).toHaveLength(3);
|
||||
expect(resolvers).toHaveLength(3);
|
||||
|
||||
// 수동으로 onload 호출해 loadPromise 완료
|
||||
resolvers.forEach(r => r());
|
||||
await loadPromise;
|
||||
|
||||
expect(firstAppendResolved).toBe(false); // placeholder, 실제 검증은 length 체크로 완료
|
||||
appendSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('CSS와 JS를 모두 병렬로 로드한다', async () => {
|
||||
const linkAppends: string[] = [];
|
||||
const scriptAppends: string[] = [];
|
||||
|
||||
const appendSpy = vi.spyOn(document.head, 'appendChild').mockImplementation(((node: any) => {
|
||||
if (node.tagName === 'LINK') {
|
||||
linkAppends.push(node.id);
|
||||
queueMicrotask(() => node.onload?.());
|
||||
} else if (node.tagName === 'SCRIPT') {
|
||||
scriptAppends.push(node.id);
|
||||
queueMicrotask(() => node.onload?.());
|
||||
}
|
||||
return node;
|
||||
}) as any);
|
||||
|
||||
const extensions: ModuleAsset[] = [
|
||||
{ identifier: 'ext-1', js: '/1.js', css: '/1.css', priority: 100 },
|
||||
{ identifier: 'ext-2', js: '/2.js', css: '/2.css', priority: 100 },
|
||||
];
|
||||
|
||||
await loader.loadActiveExtensionAssets(extensions);
|
||||
|
||||
expect(linkAppends).toEqual(['module-css-ext-1', 'module-css-ext-2']);
|
||||
expect(scriptAppends).toEqual(['module-js-ext-1', 'module-js-ext-2']);
|
||||
|
||||
appendSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('빈 배열은 no-op', async () => {
|
||||
await expect(loader.loadActiveExtensionAssets([])).resolves.toBeUndefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -99,10 +99,18 @@ export class Router {
|
||||
|
||||
/**
|
||||
* API에서 라우트 목록을 로드합니다.
|
||||
*
|
||||
* @param cacheVersion - 확장 캐시 버전. 전달 시 `?v=${version}` 쿼리로 부착되어
|
||||
* 백엔드 응답 캐시(PublicTemplateController::getRoutes)의 버전 키를 일치시킵니다.
|
||||
* 미전달 시 `v=0`으로 해석되어 구 버전과 TTL 공유 — 확장 라이프사이클 직후
|
||||
* 재로드 시에는 반드시 최신 cache_version을 전달해야 합니다.
|
||||
*/
|
||||
async loadRoutes(): Promise<void> {
|
||||
async loadRoutes(cacheVersion?: number): Promise<void> {
|
||||
try {
|
||||
const response = await fetch(`/api/templates/${this.templateIdentifier}/routes.json`);
|
||||
const versionQuery = cacheVersion !== undefined && cacheVersion > 0
|
||||
? `?v=${cacheVersion}`
|
||||
: '';
|
||||
const response = await fetch(`/api/templates/${this.templateIdentifier}/routes.json${versionQuery}`);
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(`Failed to load routes: ${response.statusText}`);
|
||||
@@ -117,7 +125,7 @@ export class Router {
|
||||
// API 응답 형태: { success: true, data: { version: "1.0.0", routes: [...] } }
|
||||
if (result.data && Array.isArray(result.data.routes)) {
|
||||
this.routes = result.data.routes;
|
||||
logger.log(`Loaded ${this.routes.length} routes`);
|
||||
logger.log(`Loaded ${this.routes.length} routes${cacheVersion ? ` (v=${cacheVersion})` : ''}`);
|
||||
} else {
|
||||
throw new Error('Invalid routes data format');
|
||||
}
|
||||
|
||||
@@ -41,6 +41,45 @@ describe('Router', () => {
|
||||
expect(router.getRoutes()).toEqual(mockRoutes);
|
||||
});
|
||||
|
||||
// @since engine-v1.19.0
|
||||
it('cacheVersion 전달 시 ?v= 쿼리 파라미터를 URL에 부착해야 합니다', async () => {
|
||||
const mockRoutes = [{ path: '/admin', layout: 'dashboard' }];
|
||||
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
success: true,
|
||||
data: { version: '1.0.0', routes: mockRoutes },
|
||||
}),
|
||||
});
|
||||
|
||||
await router.loadRoutes(1712345678);
|
||||
|
||||
expect(global.fetch).toHaveBeenCalledWith(
|
||||
'/api/templates/sirsoft-admin_basic/routes.json?v=1712345678'
|
||||
);
|
||||
expect(router.getRoutes()).toEqual(mockRoutes);
|
||||
});
|
||||
|
||||
// @since engine-v1.19.0
|
||||
it('cacheVersion 이 0 또는 undefined 이면 쿼리 파라미터 없이 호출해야 합니다', async () => {
|
||||
const mockRoutes = [{ path: '/admin', layout: 'dashboard' }];
|
||||
|
||||
(global.fetch as any).mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
success: true,
|
||||
data: { version: '1.0.0', routes: mockRoutes },
|
||||
}),
|
||||
});
|
||||
|
||||
await router.loadRoutes(0);
|
||||
expect(global.fetch).toHaveBeenLastCalledWith('/api/templates/sirsoft-admin_basic/routes.json');
|
||||
|
||||
await router.loadRoutes(undefined);
|
||||
expect(global.fetch).toHaveBeenLastCalledWith('/api/templates/sirsoft-admin_basic/routes.json');
|
||||
});
|
||||
|
||||
it('API 호출 실패 시 에러를 던져야 합니다', async () => {
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: false,
|
||||
|
||||
@@ -465,8 +465,8 @@ export class ActionDispatcher {
|
||||
/** 기본 컨텍스트 */
|
||||
private defaultContext: Partial<ActionContext>;
|
||||
|
||||
/** 전역 상태 업데이트 함수 */
|
||||
private globalStateUpdater?: (updates: any) => void;
|
||||
/** 전역 상태 업데이트 함수 (engine-v1.42.0: render 옵션 추가) */
|
||||
private globalStateUpdater?: (updates: any, options?: { render?: boolean }) => void;
|
||||
|
||||
/** ErrorHandlingResolver 연동 여부 */
|
||||
private errorHandlingSetup: boolean = false;
|
||||
@@ -1044,7 +1044,76 @@ export class ActionDispatcher {
|
||||
});
|
||||
});
|
||||
|
||||
// reloadRoutes: 라우트 다시 로드
|
||||
// reloadExtensions: 확장 상태(routes/translations/layouts) 원자적 재동기화
|
||||
//
|
||||
// 모듈/플러그인/템플릿 install/activate/deactivate/uninstall 직후 onSuccess 에서 호출합니다.
|
||||
// 내부적으로 TemplateApp.reloadExtensionState() 를 호출하여 최신 cache_version 으로
|
||||
// routes/translations/layout 캐시를 일괄 갱신합니다.
|
||||
//
|
||||
// 선택적 파라미터 `{ moduleInfo, action }` 전달 시 모듈 에셋(JS/CSS) 동적 로드/제거도
|
||||
// reloadModuleHandlers 와 동일한 방식으로 수행합니다 (플러그인도 동일 파라미터로 처리).
|
||||
//
|
||||
// @since engine-v1.19.0
|
||||
this.registerHandler('reloadExtensions', async (action: ActionDefinition, context: ActionContext) => {
|
||||
if (typeof window === 'undefined') {
|
||||
logger.warn('reloadExtensions: window is not available');
|
||||
return;
|
||||
}
|
||||
|
||||
const templateApp = (window as any).__templateApp;
|
||||
if (!templateApp) {
|
||||
logger.warn('reloadExtensions: TemplateApp not initialized');
|
||||
return;
|
||||
}
|
||||
|
||||
// 1. 확장 상태 일괄 재동기화
|
||||
if (typeof templateApp.reloadExtensionState === 'function') {
|
||||
try {
|
||||
await templateApp.reloadExtensionState();
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensions: reloadExtensionState failed', error);
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
logger.warn('reloadExtensions: TemplateApp.reloadExtensionState unavailable');
|
||||
}
|
||||
|
||||
// 2. 선택적으로 모듈/플러그인 에셋 동적 로드/제거
|
||||
const { moduleInfo, pluginInfo } = action.params || {};
|
||||
if (moduleInfo) {
|
||||
try {
|
||||
await this.executeAction(
|
||||
{
|
||||
handler: 'reloadModuleHandlers',
|
||||
params: action.params,
|
||||
} as ActionDefinition,
|
||||
context
|
||||
);
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensions: reloadModuleHandlers failed', error);
|
||||
}
|
||||
}
|
||||
if (pluginInfo) {
|
||||
try {
|
||||
await this.executeAction(
|
||||
{
|
||||
handler: 'reloadPluginHandlers',
|
||||
params: action.params,
|
||||
} as ActionDefinition,
|
||||
context
|
||||
);
|
||||
} catch (error) {
|
||||
logger.error('reloadExtensions: reloadPluginHandlers failed', error);
|
||||
}
|
||||
}
|
||||
|
||||
logger.log('reloadExtensions: done');
|
||||
});
|
||||
|
||||
// reloadRoutes: 라우트 다시 로드 (하위 호환)
|
||||
//
|
||||
// @deprecated engine-v1.19.0 이후 `reloadExtensions` 사용 권장. 본 핸들러는
|
||||
// `reloadExtensionState()` 로 위임하여 버전 기반 캐시 갱신을 보장합니다.
|
||||
this.registerHandler('reloadRoutes', async (_action: ActionDefinition, _context: ActionContext) => {
|
||||
if (typeof window === 'undefined') {
|
||||
logger.warn('reloadRoutes: window is not available');
|
||||
@@ -1057,18 +1126,21 @@ export class ActionDispatcher {
|
||||
return;
|
||||
}
|
||||
|
||||
const router = templateApp.getRouter?.();
|
||||
if (!router) {
|
||||
logger.warn('reloadRoutes: Router not available');
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
await router.loadRoutes();
|
||||
logger.log('reloadRoutes: Routes reloaded successfully');
|
||||
} catch (error) {
|
||||
logger.error('reloadRoutes: Failed to reload routes', error);
|
||||
throw error;
|
||||
if (typeof templateApp.reloadExtensionState === 'function') {
|
||||
try {
|
||||
await templateApp.reloadExtensionState();
|
||||
logger.log('reloadRoutes: delegated to reloadExtensionState');
|
||||
} catch (error) {
|
||||
logger.error('reloadRoutes: Failed to reload routes', error);
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
// 최소 호환: Router 직접 호출 (캐시 버전 없이)
|
||||
const router = templateApp.getRouter?.();
|
||||
if (router) {
|
||||
await router.loadRoutes();
|
||||
logger.log('reloadRoutes: Routes reloaded (legacy fallback)');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -1118,65 +1190,30 @@ export class ActionDispatcher {
|
||||
logger.log(`remount: ${componentId} key incremented to ${currentValue + 1}`);
|
||||
});
|
||||
|
||||
// reloadTranslations: 다국어 파일 다시 로드
|
||||
// 모듈/플러그인 활성화 후 새 캐시 버전으로 번역 데이터를 다시 로드합니다.
|
||||
// reloadTranslations: 다국어 파일 다시 로드 (하위 호환)
|
||||
//
|
||||
// @deprecated engine-v1.19.0 이후 `reloadExtensions` 사용 권장. 본 핸들러는
|
||||
// `reloadExtensionState()` 로 위임하여 다국어 외 routes/layouts 도 함께 갱신됩니다.
|
||||
this.registerHandler('reloadTranslations', async (_action: ActionDefinition, _context: ActionContext) => {
|
||||
if (typeof window === 'undefined') {
|
||||
logger.warn('reloadTranslations: window is not available');
|
||||
return;
|
||||
}
|
||||
|
||||
// TranslationEngine 싱글톤 인스턴스 가져오기
|
||||
const { TranslationEngine } = await import('./TranslationEngine');
|
||||
const translationEngine = TranslationEngine.getInstance();
|
||||
|
||||
// 현재 템플릿 ID와 로케일 가져오기
|
||||
const templateApp = (window as any).__templateApp;
|
||||
if (!templateApp) {
|
||||
logger.warn('reloadTranslations: TemplateApp not initialized');
|
||||
return;
|
||||
}
|
||||
|
||||
const config = templateApp.getConfig?.();
|
||||
if (!config?.templateId) {
|
||||
logger.warn('reloadTranslations: templateId not available');
|
||||
return;
|
||||
}
|
||||
|
||||
const locale = config.locale || 'ko';
|
||||
const fallbackLocale = 'en';
|
||||
|
||||
try {
|
||||
// 새 캐시 버전 가져오기 (모듈/플러그인 활성화 시 버전이 변경됨)
|
||||
// config.json을 호출하여 최신 cache_version을 가져옵니다.
|
||||
const configResponse = await fetch(`/api/templates/${config.templateId}/config.json?_=${Date.now()}`);
|
||||
if (configResponse.ok) {
|
||||
const templateConfig = await configResponse.json();
|
||||
// API 응답 구조: {success: true, data: {cache_version: ...}}
|
||||
const cacheVersion = templateConfig?.data?.cache_version;
|
||||
if (cacheVersion !== undefined) {
|
||||
const currentVersion = translationEngine.getCacheVersion();
|
||||
if (currentVersion !== cacheVersion) {
|
||||
logger.log('reloadTranslations: Cache version changed', currentVersion, '->', cacheVersion);
|
||||
translationEngine.setCacheVersion(cacheVersion);
|
||||
}
|
||||
}
|
||||
if (typeof templateApp.reloadExtensionState === 'function') {
|
||||
try {
|
||||
await templateApp.reloadExtensionState();
|
||||
logger.log('reloadTranslations: delegated to reloadExtensionState');
|
||||
} catch (error) {
|
||||
logger.error('reloadTranslations: Failed to reload translations', error);
|
||||
throw error;
|
||||
}
|
||||
|
||||
// 캐시 무효화를 위해 clearCache 호출 (있는 경우)
|
||||
if (typeof translationEngine.clearCache === 'function') {
|
||||
translationEngine.clearCache();
|
||||
}
|
||||
|
||||
// 현재 로케일과 폴백 로케일 다시 로드 (브라우저 캐시 무효화)
|
||||
await translationEngine.loadTranslations(config.templateId, locale, '/api', true);
|
||||
if (locale !== fallbackLocale) {
|
||||
await translationEngine.loadTranslations(config.templateId, fallbackLocale, '/api', true);
|
||||
}
|
||||
logger.log('reloadTranslations: Translations reloaded successfully');
|
||||
} catch (error) {
|
||||
logger.error('reloadTranslations: Failed to reload translations', error);
|
||||
throw error;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -2253,7 +2290,12 @@ export class ActionDispatcher {
|
||||
|
||||
case 'setState':
|
||||
logger.log('[executeAction] setState resolvedParams:', resolvedParams);
|
||||
result = await this.handleSetState(resolvedParams, context);
|
||||
// engine-v1.42.0: action.render 옵션을 __render 메타데이터로 전달
|
||||
// handleSetState는 resolvedParams를 받으므로 action 레벨 속성에 직접 접근 불가
|
||||
result = await this.handleSetState(
|
||||
action.render !== undefined ? { ...resolvedParams, __render: action.render } : resolvedParams,
|
||||
context
|
||||
);
|
||||
break;
|
||||
|
||||
case 'setError':
|
||||
@@ -2610,17 +2652,47 @@ export class ActionDispatcher {
|
||||
|
||||
// replace: true인 경우 - URL만 교체하고 데이터 소스 refetch (컴포넌트 리마운트 없음)
|
||||
// 같은 페이지에서 검색/필터 변경 시 사용
|
||||
// params.transition_overlay_target 으로 transition_overlay.target 동적 override 지원 (@since engine-v1.36.0)
|
||||
// 명명 주의: `overlay_target` 같은 광범위 키를 피하고 `transition_overlay` 스키마와 1:1 매핑되는 명시적 이름 사용.
|
||||
// 미래 다른 overlay 시스템(modal/drawer/tooltip 등)은 각자 독립 키 이름 사용 권장.
|
||||
if (params.replace === true) {
|
||||
const G7Core = (window as any).G7Core;
|
||||
if (G7Core?.updateQueryParams) {
|
||||
await G7Core.updateQueryParams(finalPath);
|
||||
logger.log('handleNavigate: Used updateQueryParams for replace mode');
|
||||
const transitionOverlayTarget = typeof (params as any).transition_overlay_target === 'string'
|
||||
? (params as any).transition_overlay_target
|
||||
: undefined;
|
||||
await G7Core.updateQueryParams(
|
||||
finalPath,
|
||||
transitionOverlayTarget ? { transitionOverlayTarget } : undefined
|
||||
);
|
||||
logger.log(
|
||||
'handleNavigate: Used updateQueryParams for replace mode',
|
||||
transitionOverlayTarget ? { transitionOverlayTarget } : undefined
|
||||
);
|
||||
// 이동 후 스크롤 위치 적용 (기본: 상단)
|
||||
this.applyScrollOption(params.scroll, params.scrollBehavior, 'top');
|
||||
return;
|
||||
}
|
||||
// G7Core.updateQueryParams가 없으면 fallback으로 React Router 사용
|
||||
logger.warn('handleNavigate: G7Core.updateQueryParams not available, falling back to React Router');
|
||||
}
|
||||
|
||||
// 미등록 라우트 fallback — 기본 openWindow, fallback: false 또는 커스텀 지정 가능
|
||||
// @since engine-v1.40.0: 관리자 ↔ 사용자 경로 교차 이동 시 404 대신 새 창 열기
|
||||
// 중요: 동기 검사로 fallback 대상 여부만 판단 — 일치/부재 시 즉시 빠져나가 기존 동기 실행 경로 유지
|
||||
const fallbackAction = this.resolveNavigateFallbackAction(finalPath, params);
|
||||
if (fallbackAction) {
|
||||
logger.warn(
|
||||
`handleNavigate: No route matched, falling back to "${fallbackAction.handler}"`
|
||||
);
|
||||
await this.dispatchAction(
|
||||
{ type: 'click', handler: fallbackAction.handler, params: fallbackAction.params } as ActionDefinition,
|
||||
context
|
||||
);
|
||||
this.applyScrollOption(params.scroll, params.scrollBehavior, 'top');
|
||||
return;
|
||||
}
|
||||
|
||||
// navigate 함수 확인
|
||||
if (!context.navigate) {
|
||||
throw new ActionError(
|
||||
@@ -2630,6 +2702,339 @@ export class ActionDispatcher {
|
||||
|
||||
// 일반 navigate (페이지 전환) - React Router 사용
|
||||
context.navigate(finalPath, { replace: params.replace === true });
|
||||
|
||||
// 이동 후 스크롤 위치 적용 (기본: 상단)
|
||||
this.applyScrollOption(params.scroll, params.scrollBehavior, 'top');
|
||||
}
|
||||
|
||||
/**
|
||||
* navigate 대상 경로가 routes.json에 없는 경우 실행할 fallback 액션을 결정합니다.
|
||||
* 매칭되거나 fallback이 비활성화된 경우 null을 반환합니다.
|
||||
*
|
||||
* 동기 검사로 동작 — 기존 navigate 동기 실행 경로를 보존하기 위해 await을 피함.
|
||||
*
|
||||
* 동작:
|
||||
* - `params.fallback === false` → null (fallback 비활성화)
|
||||
* - `params.fallback` 미지정 → 기본 openWindow
|
||||
* - `params.fallback: string` → 해당 핸들러명
|
||||
* - `params.fallback: { handler, params }` → 상세 지정
|
||||
*
|
||||
* @param finalPath query 병합이 완료된 최종 경로
|
||||
* @param params navigate params
|
||||
* @returns fallback 액션 정의 또는 null (정상 navigate 진행)
|
||||
* @since engine-v1.40.0
|
||||
*/
|
||||
private resolveNavigateFallbackAction(
|
||||
finalPath: string,
|
||||
params: Record<string, any>
|
||||
): { handler: string; params: Record<string, any> } | null {
|
||||
const fallbackOption = params.fallback;
|
||||
|
||||
// 명시적 비활성화
|
||||
if (fallbackOption === false) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// replace: true는 쿼리 갱신 전용으로 실제 경로 이동이 아니므로 fallback 대상 아님
|
||||
if (params.replace === true) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const templateApp = (window as any).__templateApp;
|
||||
const router = templateApp?.getRouter?.();
|
||||
if (!router || typeof router.match !== 'function') {
|
||||
return null;
|
||||
}
|
||||
|
||||
// 라우트가 아직 로드되지 않은 경우 fallback 미적용 — 초기 부팅 단계 또는 테스트 환경 보호
|
||||
if (typeof router.getRoutes === 'function' && router.getRoutes().length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const pathname = finalPath.split('?')[0];
|
||||
if (router.match(pathname)) {
|
||||
// 현재 템플릿에 등록된 경로 — 정상 navigate
|
||||
return null;
|
||||
}
|
||||
|
||||
// 미등록 경로 — fallback 핸들러 결정
|
||||
return this.resolveNavigateFallback(fallbackOption, finalPath, params);
|
||||
}
|
||||
|
||||
/**
|
||||
* navigate fallback 옵션을 정규화하여 { handler, params } 구조로 변환합니다.
|
||||
*
|
||||
* @param fallbackOption params.fallback 원본 값 (undefined | string | object)
|
||||
* @param finalPath query 병합 완료된 경로
|
||||
* @param originalParams 원래 navigate params
|
||||
* @returns fallback 핸들러 정의
|
||||
* @since engine-v1.40.0
|
||||
*/
|
||||
private resolveNavigateFallback(
|
||||
fallbackOption: any,
|
||||
finalPath: string,
|
||||
_originalParams: Record<string, any>
|
||||
): { handler: string; params: Record<string, any> } {
|
||||
// 기본값: openWindow
|
||||
if (fallbackOption == null) {
|
||||
return {
|
||||
handler: 'openWindow',
|
||||
params: { path: finalPath, target: '_blank' },
|
||||
};
|
||||
}
|
||||
|
||||
// 문자열: 핸들러명만 지정
|
||||
if (typeof fallbackOption === 'string') {
|
||||
return {
|
||||
handler: fallbackOption,
|
||||
params: { path: finalPath },
|
||||
};
|
||||
}
|
||||
|
||||
// 객체: 상세 지정 { handler, params }
|
||||
if (typeof fallbackOption === 'object' && typeof fallbackOption.handler === 'string') {
|
||||
return {
|
||||
handler: fallbackOption.handler,
|
||||
params: {
|
||||
path: finalPath,
|
||||
...(fallbackOption.params || {}),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// 알 수 없는 형태 — 기본값으로 폴백
|
||||
logger.warn('resolveNavigateFallback: unrecognized fallback option, using openWindow', fallbackOption);
|
||||
return {
|
||||
handler: 'openWindow',
|
||||
params: { path: finalPath, target: '_blank' },
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 이동 후 스크롤 위치를 적용합니다. (@since engine-v1.37.0)
|
||||
*
|
||||
* **단축 문법**:
|
||||
* - `"top"` (기본) → `#app` 내부의 모든 스크롤 컨테이너 + window 를 상단으로 리셋
|
||||
* - `"preserve"` → 스크롤 위치 유지 (no-op)
|
||||
* - `number` → window 를 (0, n) 으로
|
||||
* - `{ x, y }` → window 를 (x, y) 로
|
||||
* - `"#id"` / `".class"` → 해당 엘리먼트로 `scrollIntoView`
|
||||
*
|
||||
* **확장 객체 문법** (@since engine-v1.37.0):
|
||||
* ```ts
|
||||
* {
|
||||
* container?: string; // 스크롤 컨테이너 선택자 (생략 시 window)
|
||||
* to?: string | number | { x?, y? } | 'top'; // 이동 대상 (생략 시 'top')
|
||||
* block?: 'start' | 'center' | 'end' | 'nearest'; // scrollIntoView block (기본 'start')
|
||||
* offset?: number; // sticky 헤더 보정 (px, 양수 = 위쪽 여유)
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* 새 레이아웃이 DOM에 반영된 뒤 스크롤되도록 requestAnimationFrame으로 다음 tick에 실행합니다.
|
||||
*
|
||||
* @param scroll 스크롤 옵션
|
||||
* @param scrollBehavior 스크롤 애니메이션 ('instant' | 'smooth')
|
||||
* @param defaultValue 옵션 미지정 시 기본 동작 ('top' | 'preserve')
|
||||
*/
|
||||
private applyScrollOption(
|
||||
scroll: unknown,
|
||||
scrollBehavior: unknown,
|
||||
defaultValue: 'top' | 'preserve'
|
||||
): void {
|
||||
const effective = scroll === undefined ? defaultValue : scroll;
|
||||
if (effective === 'preserve') {
|
||||
return;
|
||||
}
|
||||
|
||||
// 기본값 'instant' — CSS scroll-behavior: smooth 가 전역 적용된 환경에서도
|
||||
// 페이지 전환 시 즉시 스크롤되도록 'auto' 대신 'instant' 사용.
|
||||
// 'smooth' 명시 시에만 부드러운 스크롤 적용.
|
||||
const behavior = (
|
||||
scrollBehavior === 'smooth' ? 'smooth' : 'instant'
|
||||
) as ScrollBehavior;
|
||||
|
||||
// 확장 객체 형태 감지: container/to/block/offset 중 하나라도 있으면 확장 형태
|
||||
const isExtendedForm = (v: unknown): boolean => {
|
||||
if (typeof v !== 'object' || v === null) return false;
|
||||
const obj = v as Record<string, unknown>;
|
||||
return 'container' in obj || 'to' in obj || 'block' in obj || 'offset' in obj;
|
||||
};
|
||||
|
||||
// 컨테이너에 특정 Y 좌표로 스크롤
|
||||
const scrollTargetTo = (
|
||||
target: HTMLElement | Window,
|
||||
y: number,
|
||||
x: number = 0
|
||||
) => {
|
||||
if (target === window) {
|
||||
window.scrollTo({ top: y, left: x, behavior });
|
||||
} else {
|
||||
(target as HTMLElement).scrollTo({ top: y, left: x, behavior });
|
||||
}
|
||||
};
|
||||
|
||||
// 엘리먼트를 지정된 컨테이너 안으로 스크롤 (block/offset 적용)
|
||||
const scrollElementIntoTarget = (
|
||||
el: HTMLElement,
|
||||
container: HTMLElement | Window,
|
||||
block: ScrollLogicalPosition,
|
||||
offset: number
|
||||
) => {
|
||||
if (container === window) {
|
||||
// window 컨텍스트: 네이티브 scrollIntoView 사용 후 offset 보정
|
||||
el.scrollIntoView({ behavior, block });
|
||||
if (offset) {
|
||||
window.scrollBy({ top: -offset, left: 0, behavior });
|
||||
}
|
||||
return;
|
||||
}
|
||||
const c = container as HTMLElement;
|
||||
const elRect = el.getBoundingClientRect();
|
||||
const cRect = c.getBoundingClientRect();
|
||||
const relativeTop = c.scrollTop + (elRect.top - cRect.top);
|
||||
let top: number;
|
||||
if (block === 'center') {
|
||||
top = relativeTop - (c.clientHeight - el.clientHeight) / 2;
|
||||
} else if (block === 'end') {
|
||||
top = relativeTop - (c.clientHeight - el.clientHeight);
|
||||
} else {
|
||||
// 'start' | 'nearest' → 기본 시작
|
||||
top = relativeTop;
|
||||
}
|
||||
top -= offset;
|
||||
c.scrollTo({ top: Math.max(0, top), left: 0, behavior });
|
||||
};
|
||||
|
||||
// #app 내부의 모든 스크롤 컨테이너를 상단으로 리셋
|
||||
const resetAllScrollContainers = () => {
|
||||
window.scrollTo({ top: 0, left: 0, behavior });
|
||||
const root = document.getElementById('app') ?? document.body;
|
||||
if (!root) return;
|
||||
const candidates = root.querySelectorAll<HTMLElement>('*');
|
||||
candidates.forEach((el) => {
|
||||
if (el.scrollTop === 0 && el.scrollLeft === 0) return;
|
||||
const style = window.getComputedStyle(el);
|
||||
const oy = style.overflowY;
|
||||
const ox = style.overflowX;
|
||||
const scrollable =
|
||||
oy === 'auto' || oy === 'scroll' || ox === 'auto' || ox === 'scroll';
|
||||
if (scrollable) {
|
||||
el.scrollTo({ top: 0, left: 0, behavior });
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
const run = () => {
|
||||
try {
|
||||
// --- 확장 객체 문법 ---
|
||||
if (isExtendedForm(effective)) {
|
||||
const ext = effective as {
|
||||
container?: string;
|
||||
to?: unknown;
|
||||
block?: ScrollLogicalPosition;
|
||||
offset?: number;
|
||||
};
|
||||
const block: ScrollLogicalPosition = ext.block ?? 'start';
|
||||
const offset: number = typeof ext.offset === 'number' ? ext.offset : 0;
|
||||
|
||||
// 컨테이너 해석: 지정되면 해당 엘리먼트, 아니면 window
|
||||
let container: HTMLElement | Window = window;
|
||||
if (typeof ext.container === 'string' && ext.container.length > 0) {
|
||||
const el = document.querySelector(ext.container) as HTMLElement | null;
|
||||
if (!el) {
|
||||
logger.warn(
|
||||
`applyScrollOption: container not found: ${ext.container}`
|
||||
);
|
||||
return;
|
||||
}
|
||||
container = el;
|
||||
}
|
||||
|
||||
const to = ext.to ?? 'top';
|
||||
|
||||
// to: 'top' → 컨테이너(또는 window)를 상단으로
|
||||
if (to === 'top') {
|
||||
if (container === window) {
|
||||
resetAllScrollContainers();
|
||||
} else {
|
||||
scrollTargetTo(container, 0);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// to: number → Y 좌표
|
||||
if (typeof to === 'number') {
|
||||
scrollTargetTo(container, to - offset);
|
||||
return;
|
||||
}
|
||||
|
||||
// to: { x, y } → 좌표
|
||||
if (
|
||||
typeof to === 'object' &&
|
||||
to !== null &&
|
||||
('x' in (to as object) || 'y' in (to as object))
|
||||
) {
|
||||
const { x = 0, y = 0 } = to as { x?: number; y?: number };
|
||||
scrollTargetTo(container, y - offset, x);
|
||||
return;
|
||||
}
|
||||
|
||||
// to: '#id' / '.class' → 엘리먼트로 스크롤
|
||||
if (
|
||||
typeof to === 'string' &&
|
||||
(to.startsWith('#') || to.startsWith('.'))
|
||||
) {
|
||||
const el = document.querySelector(to) as HTMLElement | null;
|
||||
if (el) {
|
||||
scrollElementIntoTarget(el, container, block, offset);
|
||||
} else {
|
||||
logger.warn(`applyScrollOption: target element not found: ${to}`);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
logger.warn('applyScrollOption: invalid "to" value in extended form', to);
|
||||
return;
|
||||
}
|
||||
|
||||
// --- 단축 문법 ---
|
||||
if (effective === 'top') {
|
||||
resetAllScrollContainers();
|
||||
return;
|
||||
}
|
||||
if (typeof effective === 'number') {
|
||||
window.scrollTo({ top: effective, left: 0, behavior });
|
||||
return;
|
||||
}
|
||||
if (
|
||||
typeof effective === 'object' &&
|
||||
effective !== null &&
|
||||
('x' in (effective as object) || 'y' in (effective as object))
|
||||
) {
|
||||
const { x = 0, y = 0 } = effective as { x?: number; y?: number };
|
||||
window.scrollTo({ top: y, left: x, behavior });
|
||||
return;
|
||||
}
|
||||
if (
|
||||
typeof effective === 'string' &&
|
||||
(effective.startsWith('#') || effective.startsWith('.'))
|
||||
) {
|
||||
const el = document.querySelector(effective);
|
||||
if (el) {
|
||||
(el as HTMLElement).scrollIntoView({ behavior, block: 'start' });
|
||||
}
|
||||
return;
|
||||
}
|
||||
} catch (err) {
|
||||
logger.warn('applyScrollOption: failed to apply scroll', err);
|
||||
}
|
||||
};
|
||||
|
||||
if (typeof window.requestAnimationFrame === 'function') {
|
||||
window.requestAnimationFrame(run);
|
||||
} else {
|
||||
run();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -2731,6 +3136,9 @@ export class ActionDispatcher {
|
||||
|
||||
// URL만 변경 (데이터소스 refetch 없음, 컴포넌트 리마운트 없음)
|
||||
window.history.replaceState(null, '', finalPath);
|
||||
|
||||
// 이동 후 스크롤 위치 적용 (기본: preserve — URL만 교체하는 용도이므로 유지)
|
||||
this.applyScrollOption(params.scroll, params.scrollBehavior, 'preserve');
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -3116,7 +3524,7 @@ export class ActionDispatcher {
|
||||
context: ActionContext
|
||||
): Promise<Record<string, any> | undefined> {
|
||||
logger.log('[handleSetState] START, params:', params);
|
||||
const { target = 'component', scope, merge, ...payload } = params;
|
||||
const { target = 'component', scope, merge, __render, ...payload } = params;
|
||||
|
||||
// DevTools 추적 시작
|
||||
const devTools = getDevTools();
|
||||
@@ -3194,7 +3602,8 @@ export class ActionDispatcher {
|
||||
};
|
||||
|
||||
logger.log('setState global:', finalPayload);
|
||||
this.globalStateUpdater(finalPayload);
|
||||
// engine-v1.42.0: __render 옵션 전파 (executeAction에서 action.render → __render로 변환)
|
||||
this.globalStateUpdater(finalPayload, { render: __render });
|
||||
|
||||
// DevTools: 상태 변경 완료 (global은 즉시 완료)
|
||||
// Note: 실제 렌더링은 비동기로 발생하므로 setTimeout으로 완료 처리
|
||||
@@ -3358,9 +3767,10 @@ export class ActionDispatcher {
|
||||
? this.deepMergeWithState(resolvedPayload, currentLocal)
|
||||
: resolvedPayload; // replace, shallow: DynamicRenderer에서 처리
|
||||
logger.log('[handleSetState] finalLocal (merged):', finalLocal);
|
||||
// engine-v1.42.0: __render 옵션 전파
|
||||
this.globalStateUpdater({
|
||||
_local: finalLocal,
|
||||
});
|
||||
}, { render: __render });
|
||||
|
||||
// engine-v1.17.2: 다음 setState에서 최신 _local 참조 가능하도록 pending 상태 업데이트
|
||||
(window as any).__g7PendingLocalState = finalLocal;
|
||||
@@ -5624,7 +6034,7 @@ export class ActionDispatcher {
|
||||
*
|
||||
* @param updater 전역 상태 업데이트 함수
|
||||
*/
|
||||
setGlobalStateUpdater(updater: (updates: any) => void): void {
|
||||
setGlobalStateUpdater(updater: (updates: any, options?: { render?: boolean }) => void): void {
|
||||
this.globalStateUpdater = updater;
|
||||
}
|
||||
|
||||
@@ -6055,6 +6465,45 @@ export class ActionDispatcher {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 프로그래매틱 호출(G7Core.state.setLocal, G7Core.dispatch)에 대한 디바운스를 처리합니다.
|
||||
*
|
||||
* 레이아웃 JSON 액션의 debounce와 동일한 타이머 인프라(debounceTimers, pendingDebounceFlushers)를
|
||||
* 사용하여 컴포넌트 언마운트 시 자동 정리 및 flushPendingDebounceTimers 연동을 보장합니다.
|
||||
*
|
||||
* @param key debounce 고유 키 (동일 키의 이전 타이머를 취소)
|
||||
* @param delay 디바운스 지연 시간 (ms)
|
||||
* @param callback 지연 후 실행할 콜백
|
||||
*
|
||||
* @since engine-v1.41.0
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* // G7Core.state.setLocal({ debounce: 300, debounceKey: 'my-key' })에서 호출
|
||||
* actionDispatcher.debouncedCall('my-key', 300, () => {
|
||||
* G7Core.state.setLocal(updates);
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
debouncedCall(key: string, delay: number, callback: () => void): void {
|
||||
// 기존 타이머 취소
|
||||
const existingTimer = this.debounceTimers.get(key);
|
||||
if (existingTimer) {
|
||||
clearTimeout(existingTimer);
|
||||
this.debounceTimers.delete(key);
|
||||
}
|
||||
|
||||
const timer = setTimeout(() => {
|
||||
this.debounceTimers.delete(key);
|
||||
this.pendingDebounceFlushers.delete(key);
|
||||
callback();
|
||||
}, delay);
|
||||
|
||||
this.debounceTimers.set(key, timer);
|
||||
// flushPendingDebounceTimers에서 즉시 실행 가능하도록 등록
|
||||
this.pendingDebounceFlushers.set(key, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* 대기 중인 모든 debounce 액션을 즉시 실행합니다.
|
||||
*
|
||||
@@ -6078,9 +6527,16 @@ export class ActionDispatcher {
|
||||
this.debounceTimers.delete(key + '_leading');
|
||||
this.pendingDebounceFlushers.delete(key);
|
||||
|
||||
// 즉시 실행
|
||||
// 즉시 실행 (render: false 콜백 포함)
|
||||
flushFn();
|
||||
}
|
||||
|
||||
// engine-v1.42.0: flush된 콜백 중 render: false로 등록된 것이 있을 수 있음
|
||||
// 저장 직전 등 flush 시점에는 항상 최신 상태를 React 트리에 반영해야 하므로
|
||||
// 빈 업데이트로 강제 렌더 트리거 (render: true가 기본값)
|
||||
if (this.globalStateUpdater) {
|
||||
this.globalStateUpdater({});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -5,6 +5,186 @@
|
||||
>
|
||||
> 형식: [Keep a Changelog](https://keepachangelog.com/ko/1.1.0/)
|
||||
|
||||
## [engine-v1.42.0] - 2026-04-16
|
||||
|
||||
### Added
|
||||
|
||||
- `render: false` 선택적 리렌더 제어 — 상태 값은 저장하되 React 리렌더를 건너뛰는 옵션. CKEditor 등 자체 DOM을 관리하는 플러그인에서 타이핑 중 전체 폼 리렌더(37,000+ 바인딩 재평가) 방지. `flushPendingDebounceTimers` 실행 시 항상 render: true 강제로 저장 직전 데이터 정합성 보장 (TemplateApp, G7CoreGlobals, ActionDispatcher)
|
||||
- `G7Core.state.setLocal(updates, { render: false })` — 로컬 상태 사일런트 업데이트
|
||||
- `G7Core.state.set(updates, { render: false })` — 전역 상태 사일런트 업데이트
|
||||
- `setState` 핸들러 `render: false` — 레이아웃 JSON 액션 레벨 옵션: `{ "handler": "setState", "render": false }`
|
||||
|
||||
## [engine-v1.41.0] - 2026-04-16
|
||||
|
||||
### Added
|
||||
|
||||
- `G7Core.state.setLocal()` `debounce`/`debounceKey` 옵션 — 프로그래매틱 호출에서 G7 표준 디바운스 사용 가능. ActionDispatcher의 기존 타이머 인프라(자동 정리, flushPendingDebounceTimers 연동)를 활용 (G7CoreGlobals)
|
||||
- `G7Core.dispatch()` `debounce`/`debounceKey` 옵션 — 액션 시스템 진입점에서도 표준 디바운스 지원 (G7CoreGlobals)
|
||||
- `ActionDispatcher.debouncedCall()` 공개 메서드 — 프로그래매틱 debounce용 타이머 관리 (ActionDispatcher)
|
||||
|
||||
### Fixed
|
||||
|
||||
- `setLocal()` 내부 `baseLocal` 계산 시 stale `actionContext.state`의 빈 배열이 `globalLocal`의 정상 API 데이터를 `deepMerge`로 교체하는 오염 경로 차단 — `deepMerge` → `addMissingLeafKeys` 전략으로 변경하여 `globalLocal`(committed 상태)의 기존 값을 보존하면서 `dynamicLocal`(setState 전용 키)만 안전하게 추가. CKEditor 등 플러그인 onMount에서 `setLocal` 호출 시 init_actions 기본값(빈 배열)이 API 데이터를 덮어쓰는 문제 해소 (G7CoreGlobals)
|
||||
- SPA 네비게이션 시 `_localInit` 미적용 상태에서 stale `dynamicState` 병합 방지 — `lastProcessedInitRef` ref 기반 감지로 `extendedDataContext` 병합에서 stale `dynamicState` 건너뛰기 (DynamicRenderer)
|
||||
|
||||
## [engine-v1.40.0] - 2026-04-15
|
||||
|
||||
### Added
|
||||
|
||||
- `navigate` 핸들러 `params.fallback` 옵션 — 대상 경로가 현재 템플릿의 `routes.json`에 매칭되지 않을 때 대체 핸들러로 분기. **기본값은 `openWindow`**(새 창 열기)로, 관리자 ↔ 사용자 템플릿 간 경로 교차 이동 시 404 페이지 대신 새 창으로 열림. `fallback: false` 로 비활성화 가능, `fallback: "핸들러명"` 또는 `fallback: { handler, params }` 로 커스텀 지정 가능. `replace: true` 분기(쿼리 갱신 전용)에는 미적용. 알림센터에서 알림 클릭 시 교차 템플릿 경로 접근 문제 해결 (ActionDispatcher)
|
||||
|
||||
## [engine-v1.39.0] - 2026-04-15
|
||||
|
||||
### Changed
|
||||
|
||||
- 확장 에셋 로딩 병렬화 — `ModuleAssetLoader.loadActiveExtensionAssets()` 가 JS 번들을 `for...await` 로 직렬 fetch 하던 것을 `Promise.all(map(loadJS))` 병렬 fetch 로 전환. 실행 순서는 `script.async = false` + priority 정렬 순서로 DOM append 되어 HTML 사양에 따라 그대로 보장됨. 사용자 화면 진입 시 5개 IIFE 확장 기준 staircase 로딩이 ~1.3초 → ~350ms 로 단축. 코드베이스 감사 결과 cross-extension 참조·priority 차등·등록 순서 의존성 모두 없음을 확인한 후 적용 (ModuleAssetLoader)
|
||||
|
||||
## [engine-v1.38.2] - 2026-04-15
|
||||
|
||||
### Fixed
|
||||
|
||||
- (engine-v1.38.2) `{{$event.target.checked ? '$t:admin.modules.activate_success' : '$t:admin.modules.deactivate_success'}}` 같은 **조건부 표현식 안의 따옴표 `$t:` 패턴이 raw key 를 토스트로 노출하던 버그** — `DataBindingEngine.preprocessTranslationTokens()` 가 따옴표 안의 `'$t:KEY'` 를 `$t('KEY')` 함수 호출로 변환하고, `$t()` 헬퍼가 `context.$templateId` 를 templateId 로 사용하는데, ActionDispatcher 의 `createHandler()` 가 빌드한 action data context 가 항상 `$templateId` 를 포함하지는 않아 빈 templateId 로 lookup 이 실패하던 문제. `$t()` 가 이제 `context.$templateId` 가 없으면 `window.__templateApp.getConfig()` 로부터 templateId/locale 을 회수한다 (DataBindingEngine). admin_module_list / admin_plugin_list / admin_role_list 등 onSuccess 토스트 메시지가 다시 정상 번역됨
|
||||
|
||||
## [engine-v1.38.1] - 2026-04-15
|
||||
|
||||
### Fixed
|
||||
|
||||
- (engine-v1.38.1) `reloadExtensions` 병렬 블록에서 동시에 실행되는 `toast($t:...)` 가 raw 다국어 키(예: `admin.modules.activate_success`)를 그대로 노출하던 경합 — `TranslationEngine.setCacheVersion()` 내부의 `clearCache()` 호출이 활성 `this.translations` 맵을 비워서, 새 `loadTranslations()` 가 fetch를 완료하기 전에 실행되는 `translate()` 호출이 빈 사전을 만나 폴백 규칙(3번째 단계)에 따라 원본 키를 반환하던 문제. `setCacheVersion()` 이 이제 TTL 캐시(`this.cache`)만 비우고 활성 사전(`this.translations`)은 그대로 유지 — `loadTranslations()` 완료 시점에 `translations.set(cacheKey, dictionary)` 로 원자 교체되므로 레이스 윈도우가 제거됨. `TemplateApp.reloadExtensionState()` 도 명시적 `clearCache()` 호출을 제거. 유사 사례 전수 적용(레이아웃 수정 불요) — 모든 `$t:` 해석 경로가 동일 보호를 받음 (TranslationEngine, TemplateApp)
|
||||
|
||||
## [engine-v1.38.0] - 2026-04-15
|
||||
|
||||
### Added
|
||||
|
||||
- `reloadExtensions` 통합 핸들러 — 확장(모듈/플러그인/템플릿)의 install/activate/deactivate/uninstall 직후 onSuccess 체인에서 호출하여 페이지 전체 새로고침 없이 확장 상태를 원자적으로 재동기화. 내부적으로 `TemplateApp.reloadExtensionState()` 를 호출하여 최신 `cache_version` 획득 → localStorage 반영 → Router routes 재fetch → LayoutLoader 캐시 클리어 → TranslationEngine 재로드까지 일괄 수행. 선택 파라미터 `{ moduleInfo, pluginInfo, action: "add"|"remove" }` 전달 시 `reloadModuleHandlers` / `reloadPluginHandlers` 로직도 통합 실행하여 JS/CSS 에셋을 동적으로 로드/제거 (ActionDispatcher)
|
||||
- `TemplateApp.reloadExtensionState()` public 메서드 — config.json 에서 새 cache_version 획득 후 Router/LayoutLoader/TranslationEngine 을 순차 갱신. 각 단계는 try/catch 로 격리되어 한 단계 실패가 다른 단계를 막지 않음 (TemplateApp)
|
||||
- `Router.loadRoutes(cacheVersion?: number)` 파라미터 — 전달 시 `?v=${version}` 쿼리로 부착되어 백엔드 `PublicTemplateController::getRoutes` 의 응답 캐시 버전 키를 일치시킴. 미전달 시 구 버전 동작 유지 (Router)
|
||||
|
||||
### Fixed
|
||||
|
||||
- 확장 활성화/비활성화 후 전체 새로고침 없이는 새 라우트가 반영되지 않던 버그 — `Router.loadRoutes()` 가 캐시 버전 쿼리 없이 `/api/templates/{id}/routes.json` 을 요청하여 백엔드의 `template.routes.{id}.v0` 캐시 키에 과거 응답이 고정되거나 TTL(1시간) 동안 오염된 상태가 재사용되던 문제. `reloadExtensions` 핸들러가 최신 `cache_version` 으로 fetch 하도록 수정하여 activate API 완료 시점에 즉시 routes 가 반영됨 (Router, TemplateApp, ActionDispatcher)
|
||||
|
||||
### Deprecated
|
||||
|
||||
- `reloadRoutes` 핸들러 — `reloadExtensions` 로 대체 예정. 현재는 `TemplateApp.reloadExtensionState()` 로 위임하여 하위 호환 유지 (ActionDispatcher)
|
||||
- `reloadTranslations` 핸들러 — `reloadExtensions` 로 대체 예정. 현재는 `TemplateApp.reloadExtensionState()` 로 위임 (ActionDispatcher)
|
||||
|
||||
## [engine-v1.37.0] - 2026-04-14
|
||||
|
||||
### Added
|
||||
|
||||
- `navigate` 핸들러 `params.scroll` / `params.scrollBehavior` 옵션 — 페이지 이동 후 스크롤 위치를 선언적으로 제어. 지원 값: `"top"` (기본) / `"preserve"` / 숫자 / `{x, y}` / `"#selector"`. `requestAnimationFrame`으로 다음 tick에 적용하여 새 레이아웃 DOM 반영 후 정확한 위치로 이동. `replace: true` 분기(`updateQueryParams`)에도 동일하게 적용. `scrollBehavior` 기본값은 `"instant"` — 템플릿 CSS의 `scroll-behavior: smooth` 전역 설정을 무시하고 페이지 전환 시 즉시 이동하도록 강제. `"smooth"` 명시 시에만 부드러운 스크롤 (ActionDispatcher)
|
||||
- `replaceUrl` 핸들러 `params.scroll` / `params.scrollBehavior` 옵션 — 기본값은 `"preserve"` (URL만 교체하는 용도이므로 스크롤 유지). 명시적으로 `"top"` 등 지정 가능 (ActionDispatcher)
|
||||
- `scroll: "top"` 동작 시 `window` 뿐 아니라 `#app` 내부의 모든 스크롤 컨테이너(`overflow-y: auto|scroll` 또는 `overflow-x: auto|scroll`)를 함께 상단으로 리셋 — 관리자 템플릿처럼 `html/body`가 `overflow: hidden`이고 내부 div가 실제 스크롤 컨테이너인 구조에서도 `window.scrollTo`만으로는 효과가 없어 스크롤이 이동하지 않던 문제 해결 (ActionDispatcher)
|
||||
- `scroll` 확장 객체 문법 — `{ container?, to?, block?, offset? }` 형태로 특정 스크롤 컨테이너 지정, sticky 헤더 오프셋, `scrollIntoView`의 `block` 위치(`start`/`center`/`end`/`nearest`) 선택을 지원. 관리자 템플릿의 `#right_content_area` 같은 내부 스크롤 컨테이너에 대해 Y 좌표 이동, 엘리먼트로 이동(중앙/상단/하단 정렬), 오프셋 보정이 가능 (ActionDispatcher)
|
||||
|
||||
### Changed
|
||||
|
||||
- **Breaking**: `navigate` 핸들러 기본 스크롤 동작 변경 — 기존에는 페이지 이동 후 이전 스크롤 위치가 그대로 유지되어 일반적인 하이퍼링크 이동 UX와 어긋났음. 이제 기본값 `"top"`으로 이동 시 최상단에서 새 페이지가 시작됨. 스크롤 유지가 필요한 케이스(검색 필터, 페이지네이션 등)는 `scroll: "preserve"` 명시 필요 (ActionDispatcher)
|
||||
|
||||
## [engine-v1.36.0] - 2026-04-13
|
||||
|
||||
### Added
|
||||
|
||||
- `navigate` 핸들러 `params.transition_overlay_target` 옵션 — `replace: true` 로 `updateQueryParams` 경로 진입 시 `transition_overlay.target` 을 호출별로 동적 override. 환경설정 알림 탭 안의 채널 탭 등 **탭 속 서브 탭** 클릭 시 서브 탭 콘텐츠 영역에만 spinner 가 표시되도록 한다. 미지정 시 `transition_overlay.target` (베이스 또는 자식 merge 결과) 사용 (ActionDispatcher, G7CoreGlobals, TemplateApp)
|
||||
- `G7Core.updateQueryParams(newPath, options?)` — 두 번째 인자 `options.transitionOverlayTarget` 로 호출별 target override 지원 (G7CoreGlobals, TemplateApp)
|
||||
|
||||
## [engine-v1.35.0] - 2026-04-13
|
||||
|
||||
### Added
|
||||
|
||||
- `updateQueryParams` 경로에서 `transition_overlay` spinner/skeleton 자동 트리거 — `navigate replace:true` 로 탭 전환/검색/페이지네이션 시 handleRouteChange 대신 updateQueryParams 경로에 진입할 때도 `blocking` 또는 `wait_for` 에 명시된 progressive 데이터소스가 1개 이상 refetch 대상이면 오버레이 표시. fetch 완료/에러 시 자동 hide. handleRouteChange step 2.5 와 동일 정책 (TemplateApp)
|
||||
|
||||
## [engine-v1.34.0] - 2026-04-13
|
||||
|
||||
### Added
|
||||
|
||||
- `transition_overlay.wait_for` 옵션 — blocking 데이터소스가 없는 페이지에서도 명시된 progressive 데이터소스가 fetch 완료될 때까지 spinner/skeleton 오버레이가 표시되도록 하는 명시적 가드. background/websocket 데이터소스는 의도상 사용자 차단 불가하므로 자동 무시되며 백엔드 검증(UpdateLayoutContentRequest)에서 사전 차단됨 (TemplateApp, LayoutLoader 타입)
|
||||
|
||||
### Changed
|
||||
|
||||
- `LayoutService::mergeLayouts` 의 `transition_overlay` 병합을 shallow merge 로 변경 — 자식 레이아웃이 `wait_for` 만 명시해도 부모(베이스)의 `enabled/style/target/spinner` 설정이 보존되어 자식이 부분 override 가능. boolean/비배열 케이스는 기존 자식 우선/부모 폴백 유지 (LayoutService)
|
||||
|
||||
## [engine-v1.33.1] - 2026-04-10
|
||||
|
||||
### Fixed
|
||||
|
||||
- WebSocket 리스너 중복 누적 버그 수정 — `WebSocketManager.unsubscribe()`가 `subscriptions` Map에서만 엔트리를 제거할 뿐 Echo 채널의 `listen()` 리스너를 해제하지 않아, route 변경 시 재구독 시 Echo가 동일 채널 인스턴스를 재사용하며 listener가 누적됨. 결과: 단일 route에서 알림 폼 저장 등으로 route가 여러 번 전환되면 N번 중복 수신 (예: 수정 창에서 비밀번호 변경 알림 토스트 8번 실행). `channelInstance.stopListening('.${event}')` 명시 호출로 수정 (WebSocketManager.ts)
|
||||
|
||||
## [engine-v1.33.0] - 2026-04-10
|
||||
|
||||
### Added
|
||||
|
||||
- WebSocket 데이터소스에 `onReceive` 액션 배열 지원 — 메시지 수신 시 정의된 액션들을 순차 실행. `$args[0]` 또는 `$event`로 페이로드 접근 가능. refetchDataSource/toast 등 모든 핸들러 사용 가능. 사용 예시: 알림 수신 시 `notification_unread_count` 자동 refetch + 토스트 표시 (DataSourceManager.ts, TemplateApp.ts)
|
||||
|
||||
## [engine-v1.32.5] - 2026-04-09
|
||||
|
||||
### Fixed
|
||||
|
||||
- `updateQueryParams` 데이터소스 refetch 인덱스 매핑 어긋남 — WebSocket 소스가 `currentDataSources`에 포함된 레이아웃(예: `_admin_base.json`의 `notification_ws`)에서 `navigate replace:true`(탭 전환 등) 호출 시 `fetchDataSourcesWithResults`가 WebSocket을 내부 필터링하여 results 배열이 짧아지는데 호출자는 `autoFetchDataSources[i]`로 매핑해 데이터가 잘못된 키에 기록됨. 증상: 환경설정/알림설정 탭 클릭 시 `_local.form`이 다른 데이터소스 응답으로 초기화되어 탭 내용이 빈 화면 (TemplateApp)
|
||||
- 원인 1: `updateQueryParams` 가 인덱스 기반 `for (let i = 0; i < results.length; i++) { autoFetchDataSources[i] }` 매핑 사용 → `handleRouteChange` blocking 경로(`results.forEach((r) => blockingData[r.id] = r.data)`)와 일관성 없음
|
||||
- 수정 1: `updateQueryParams` 를 `result.id` 기반 Map 조회로 변경하여 handleRouteChange 패턴과 통일 (TemplateApp)
|
||||
- 원인 2: `updateQueryParams` 가 WebSocket 소스를 사전 제외하지 않아 `fetchDataSourcesWithResults` 내부 silent filter와 계약 불일치
|
||||
- 수정 2: `updateQueryParams` 에서 WebSocket 사전 제외 추가 — handleRouteChange progressive 경로(engine-v1.32.2)와 동일 정책 (TemplateApp)
|
||||
- 원인 3: `fetchDataSourcesWithResults` 의 내부 WebSocket 필터가 silent — 호출자가 WebSocket을 넘겨도 경고 없이 조용히 제거되어 인덱스 매핑 어긋남 버그가 숨겨짐
|
||||
- 수정 3: `fetchDataSourcesWithResults` 에서 WebSocket 소스 수신 시 경고 로그 추가 — 내부 필터는 safety net으로 유지하되 호출자 필터 누락을 조기 발견 가능 (DataSourceManager)
|
||||
|
||||
## [engine-v1.32.4] - 2026-04-09
|
||||
|
||||
### Fixed
|
||||
|
||||
- WebSocket 채널 빈 세그먼트 검증 강화 — 표현식이 undefined로 평가되어 빈 문자열로 치환되면 trailing dot/연속 dot이 발생해도 미평가 마커(`{{`)가 없어 방어 로직을 우회. `isInvalidChannel` 헬퍼 추가하여 trailing/leading/연속 빈 세그먼트(`.`, `:`)도 감지 후 구독 건너뜀. 진단을 위해 컨텍스트 키 목록을 경고 로그에 포함 (DataSourceManager)
|
||||
- WebSocket 구독 직전 컨텍스트 키 디버그 로그 추가 — 표현식 평가 실패 진단용 (TemplateApp)
|
||||
|
||||
## [engine-v1.32.3] - 2026-04-09
|
||||
|
||||
### Fixed
|
||||
|
||||
- WebSocket 채널/이벤트 표현식 평가 누락 — `core.user.notifications.{{current_user.data.id}}` 같은 표현식이 평가 없이 그대로 구독되어 백엔드 채널 패턴 매칭 실패 → broadcasting/auth가 AccessDeniedHttpException 발생. `subscribeWebSockets`에 `bindingContext` 파라미터 추가, channel/event 모두 `resolveExpressionString`으로 평가 (DataSourceManager)
|
||||
- WebSocket 구독 시점이 progressive fetch 이전이라 fetched 데이터 참조 표현식 평가 불가 — Step 6 WebSocket 구독을 progressive fetch 완료 후(Step 7)로 이동하여 모든 데이터소스가 평가 컨텍스트에 포함되도록 함 (TemplateApp)
|
||||
- WebSocket 미평가 표현식 방어 로직 — 평가 후에도 `{{` 마커가 남아있으면 구독 건너뛰고 경고 로그 (DataSourceManager)
|
||||
|
||||
## [engine-v1.32.2] - 2026-04-09
|
||||
|
||||
### Fixed
|
||||
|
||||
- WebSocket 데이터소스가 progressive 목록에 포함되어 blur_until_loaded 영구 블러 — WebSocket은 이벤트 리스너이지 데이터 제공자가 아니므로 progressive 초기화에서 제외 (TemplateApp)
|
||||
|
||||
## [engine-v1.32.1] - 2026-04-09
|
||||
|
||||
### Fixed
|
||||
|
||||
- auth_mode: 'required' 데이터소스에서 토큰 없을 때 API 요청 스킵 — 비로그인 상태에서 인증 필수 API 호출 → 401 → onUnauthorized 로그인 리다이렉트 무한 루프 방지 (DataSourceManager)
|
||||
|
||||
## [engine-v1.32.0] - 2026-04-08
|
||||
|
||||
### Added
|
||||
|
||||
- extensionPointCallbacks — extension_point에서 콜백 액션 객체를 props와 분리하여 전달하는 기능 추가 (DynamicRenderer, LayoutExtensionService)
|
||||
- `props`: 데이터 전달용 — `resolveObject()`로 표현식 재귀 평가 (일반 props와 동일 수준)
|
||||
- `callbacks`: 액션 객체 전달용 — 평가 없이 그대로 전달 (ActionDispatcher 실행 시점 평가)
|
||||
|
||||
### Fixed
|
||||
|
||||
- extensionPointProps 표현식 미평가 버그 수정 — 호스트가 `"{{route.id}}"` 같은 표현식을 넘기면 평가 없이 raw 문자열로 전달되던 문제 해결 (DynamicRenderer)
|
||||
|
||||
## [engine-v1.31.0] - 2026-04-02
|
||||
|
||||
### Added
|
||||
|
||||
- resolvedProps 참조 안정화 — 바인딩 해석 결과의 값이 이전과 동일하면 이전 객체 참조를 반환하여 하위 컴포넌트의 React.memo가 실제로 작동하도록 개선 (DynamicRenderer)
|
||||
- ComponentRegistry에서 컴포넌트 등록 시 React.memo 자동 래핑 — props 변경이 없는 컴포넌트의 불필요한 리렌더링 방지 (ComponentRegistry)
|
||||
|
||||
### Fixed
|
||||
|
||||
- DevTools 캐시 탭 Hit Rate 카드와 프로그레스 바에서 hitRate(0~1)를 백분율 변환하지 않아 0.9%로 표시되던 버그 수정 (CacheTab)
|
||||
|
||||
## [engine-v1.30.0] - 2026-04-02
|
||||
|
||||
### Added
|
||||
|
||||
- SortableItemWrapper에 `as` prop 추가 — wrapper 요소를 지정 가능 (기본: `div`, Table 내부: `tr`)
|
||||
- DynamicRenderer에서 sortable 설정의 `wrapperElement` 옵션을 SortableItemWrapper에 전달
|
||||
|
||||
## [engine-v1.29.2]
|
||||
|
||||
### Fixed
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
* - 전역 레지스트리 관리 및 캐싱
|
||||
*/
|
||||
|
||||
import type { ComponentType } from 'react';
|
||||
import React, { type ComponentType } from 'react';
|
||||
import { createLogger } from '../utils/Logger';
|
||||
|
||||
const logger = createLogger('ComponentRegistry');
|
||||
@@ -422,6 +422,11 @@ export class ComponentRegistry {
|
||||
|
||||
/**
|
||||
* 개별 컴포넌트 등록
|
||||
*
|
||||
* 등록 시 React.memo로 자동 래핑하여, props가 변경되지 않은 컴포넌트의
|
||||
* 불필요한 리렌더링을 방지합니다.
|
||||
*
|
||||
* @since engine-v1.25.0
|
||||
*/
|
||||
private registerComponent(
|
||||
name: string,
|
||||
@@ -432,8 +437,15 @@ export class ComponentRegistry {
|
||||
logger.warn(`Component '${name}' already registered, overwriting`);
|
||||
}
|
||||
|
||||
// 성능 최적화: React.memo 자동 래핑 (engine-v1.25.0)
|
||||
// - basic/composite/layout 모든 타입에 적용
|
||||
// - forwardRef 컴포넌트도 memo(forwardRef(...)) 패턴으로 정상 작동
|
||||
// - 내부 useState/useRef는 memo와 무관 (외부 props 비교만 수행)
|
||||
// - worst case: memo 비교 실패 → 기존과 동일하게 리렌더 (회귀 없음)
|
||||
const memoizedComponent = React.memo(component);
|
||||
|
||||
this.registry[name] = {
|
||||
component,
|
||||
component: memoizedComponent,
|
||||
metadata,
|
||||
};
|
||||
|
||||
|
||||
@@ -1119,10 +1119,27 @@ export class DataBindingEngine {
|
||||
// 번역 키를 사용하여 다국어 텍스트를 반환
|
||||
// 사용법: $t('admin.settings.info.write_only') - 번역된 텍스트 반환
|
||||
// 컨텍스트에서 번역 관련 정보 추출
|
||||
const templateId = context.$templateId || '';
|
||||
//
|
||||
// @since engine-v1.38.2 ActionDispatcher 경로 fallback — bindActionsToProps
|
||||
// 이후 createHandler 에서 빌드된 action data context 는 `$templateId`/`$locale`
|
||||
// 을 명시적으로 포함하지 않을 수 있다. 이 경우 `window.__templateApp.getConfig()`
|
||||
// 로부터 회수하여 `{{$event.target.checked ? '$t:A' : '$t:B'}}` 같은 조건부
|
||||
// $t: 평가가 raw key 를 반환하던 버그를 해결한다.
|
||||
let templateId = context.$templateId;
|
||||
let resolvedLocale = locale;
|
||||
if (!templateId && typeof window !== 'undefined') {
|
||||
const templateApp = (window as any).__templateApp;
|
||||
const appConfig = templateApp?.getConfig?.();
|
||||
if (appConfig?.templateId) {
|
||||
templateId = appConfig.templateId;
|
||||
if (!context.$locale && appConfig.locale) {
|
||||
resolvedLocale = appConfig.locale;
|
||||
}
|
||||
}
|
||||
}
|
||||
const translationContext = {
|
||||
templateId,
|
||||
locale,
|
||||
templateId: templateId || '',
|
||||
locale: resolvedLocale,
|
||||
};
|
||||
extendedContext.$t = (key: string): string => {
|
||||
if (!key || typeof key !== 'string') {
|
||||
|
||||
@@ -473,6 +473,22 @@ export interface DataSource {
|
||||
*/
|
||||
target_source?: string;
|
||||
|
||||
/**
|
||||
* WebSocket 이벤트 수신 시 실행할 액션 목록 (engine-v1.33.0+)
|
||||
*
|
||||
* WebSocket 이벤트 수신 시 각 액션이 순차적으로 실행됩니다.
|
||||
* 액션의 `$args[0]`로 수신 페이로드에 접근할 수 있습니다.
|
||||
*
|
||||
* 사용 예시: 수신 시 관련 데이터소스 refetch + 토스트 알림 표시
|
||||
*
|
||||
* @example
|
||||
* [
|
||||
* { "handler": "refetchDataSource", "params": { "dataSourceId": "notifications" } },
|
||||
* { "handler": "toast", "params": { "type": "info", "message": "{{$args[0].subject}}" } }
|
||||
* ]
|
||||
*/
|
||||
onReceive?: any[];
|
||||
|
||||
/**
|
||||
* API 호출 실패 시 사용할 기본 데이터
|
||||
*
|
||||
@@ -1041,8 +1057,23 @@ export class DataSourceManager {
|
||||
localState?: Record<string, any>,
|
||||
options?: { ignoreAutoFetch?: boolean },
|
||||
): Promise<DataSourceResult[]> {
|
||||
// 계약: WebSocket 소스는 fetch 대상이 아님 — 호출자가 사전 필터링해야 함 (engine-v1.32.5)
|
||||
// 내부 filter는 safety net으로 유지하되, 호출자가 필터를 누락하면 dev 모드에서 경고
|
||||
// (이전에는 silent filter로 인해 호출자의 인덱스 기반 매핑이 조용히 어긋나는 버그 발생)
|
||||
const hasWebSocket = sources.some((source) => source.type === 'websocket');
|
||||
if (hasWebSocket) {
|
||||
const wsIds = sources
|
||||
.filter((source) => source.type === 'websocket')
|
||||
.map((s) => s.id)
|
||||
.join(', ');
|
||||
logger.warn(
|
||||
`fetchDataSourcesWithResults received WebSocket sources (caller should filter them out before calling): ${wsIds}. ` +
|
||||
`WebSocket sources are event listeners, not data providers — they should not be passed to fetch.`
|
||||
);
|
||||
}
|
||||
|
||||
// ignoreAutoFetch 옵션이 true면 auto_fetch 필터 무시 (refetchDataSource에서 사용)
|
||||
// 그렇지 않으면 auto_fetch가 true인 데이터 소스만 처리 (websocket 타입 제외)
|
||||
// 그렇지 않으면 auto_fetch가 true인 데이터 소스만 처리 (websocket 타입 제외 — safety net)
|
||||
const targetSources = options?.ignoreAutoFetch
|
||||
? sources.filter((source) => source.type !== 'websocket')
|
||||
: sources.filter(
|
||||
@@ -1492,11 +1523,28 @@ export class DataSourceManager {
|
||||
// auth_mode 결정 (auth_required: true는 'required'로 처리하여 하위 호환성 유지)
|
||||
const authMode = source.auth_mode ?? (source.auth_required === true ? 'required' : 'none');
|
||||
|
||||
// 토큰 유무 확인 (optional 모드에서 사용)
|
||||
// 토큰 유무 확인
|
||||
const hasToken = AuthManager.getInstance().isAuthenticated();
|
||||
|
||||
// auth_mode: 'required'이고 토큰이 없으면 요청 스킵 (fallback 사용)
|
||||
// 토큰 없이 ApiClient로 요청하면 401 → onUnauthorized → 로그인 리다이렉트 발생
|
||||
if (authMode === 'required' && !hasToken) {
|
||||
logger.log(`[DataSourceManager] Skipping ${source.id}: auth_mode is 'required' but no token available`);
|
||||
if (devTools?.isEnabled()) {
|
||||
devTools.trackDataSourceError(source.id, 'Skipped: auth_mode required but not authenticated');
|
||||
if (requestId) {
|
||||
devTools.failRequest(requestId, 'Skipped: not authenticated');
|
||||
}
|
||||
}
|
||||
const skipError = new Error('Auth required but not authenticated') as any;
|
||||
skipError.response = { status: 401, statusText: 'Unauthorized', data: null };
|
||||
skipError.status = 401;
|
||||
skipError._authSkipped = true;
|
||||
throw skipError;
|
||||
}
|
||||
|
||||
// ApiClient 사용 여부 결정
|
||||
// - required: 항상 ApiClient 사용
|
||||
// - required: ApiClient 사용 (토큰 존재 확인됨)
|
||||
// - optional: 토큰이 있을 때만 ApiClient 사용
|
||||
// - none: 일반 fetch 사용
|
||||
const useApiClient = authMode === 'required' || (authMode === 'optional' && hasToken);
|
||||
@@ -1755,7 +1803,8 @@ export class DataSourceManager {
|
||||
*/
|
||||
subscribeWebSockets(
|
||||
sources: DataSource[],
|
||||
onUpdate: (sourceId: string, data: unknown) => void
|
||||
onUpdate: (sourceId: string, data: unknown) => void,
|
||||
bindingContext: Record<string, any> = {}
|
||||
): string[] {
|
||||
const subscriptionKeys: string[] = [];
|
||||
const webSocketSources = sources.filter((s) => s.type === 'websocket');
|
||||
@@ -1770,9 +1819,42 @@ export class DataSourceManager {
|
||||
return;
|
||||
}
|
||||
|
||||
// 채널/이벤트명에 포함된 표현식 평가 (예: core.user.notifications.{{current_user.data.uuid}})
|
||||
// 평가 실패 시 원본 문자열 유지 — 정적 채널은 영향 없음
|
||||
let resolvedChannel: string;
|
||||
let resolvedEvent: string;
|
||||
try {
|
||||
resolvedChannel = resolveExpressionString(source.channel, bindingContext, { skipCache: true });
|
||||
resolvedEvent = resolveExpressionString(source.event, bindingContext, { skipCache: true });
|
||||
} catch (error) {
|
||||
logger.error(`Failed to resolve WebSocket channel/event for source ${source.id}:`, error);
|
||||
return;
|
||||
}
|
||||
|
||||
// 평가 결과 검증: 표현식 미평가, 빈 세그먼트(trailing/leading/연속 dot), 빈 문자열은 모두 잘못된 채널
|
||||
// 표현식이 undefined로 평가되어 빈 문자열로 치환된 경우 trailing dot 등이 발생함
|
||||
const isInvalidChannel = (channel: string): boolean => {
|
||||
if (!channel || channel.trim() === '') return true;
|
||||
if (channel.includes('{{')) return true; // 미평가 표현식
|
||||
if (channel.endsWith('.') || channel.endsWith(':')) return true; // trailing 빈 세그먼트
|
||||
if (channel.startsWith('.') || channel.startsWith(':')) return true; // leading 빈 세그먼트
|
||||
if (channel.includes('..') || channel.includes('::')) return true; // 중간 빈 세그먼트
|
||||
return false;
|
||||
};
|
||||
|
||||
if (isInvalidChannel(resolvedChannel) || isInvalidChannel(resolvedEvent)) {
|
||||
logger.warn(
|
||||
`WebSocket source ${source.id} has invalid channel/event after expression resolution, skipping. ` +
|
||||
`Original channel="${source.channel}", resolved="${resolvedChannel}". ` +
|
||||
`Original event="${source.event}", resolved="${resolvedEvent}". ` +
|
||||
`Available context keys: [${Object.keys(bindingContext).join(', ')}]`
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
const key = webSocketManager.subscribe(
|
||||
source.channel,
|
||||
source.event,
|
||||
resolvedChannel,
|
||||
resolvedEvent,
|
||||
(data: unknown) => {
|
||||
// target_source가 지정된 경우 해당 소스의 캐시 업데이트
|
||||
const targetId = source.target_source || source.id;
|
||||
|
||||
@@ -31,6 +31,7 @@ import type { ConditionsProperty } from './helpers/ConditionEvaluator';
|
||||
import { useTransitionState } from './TransitionContext';
|
||||
import { useResponsive } from './ResponsiveContext';
|
||||
import { createLogger } from '../utils/Logger';
|
||||
import { shallowObjectEqual } from '../hooks/useControllableState';
|
||||
import type { G7DevToolsInterface } from './G7CoreGlobals';
|
||||
|
||||
const logger = createLogger('DynamicRenderer');
|
||||
@@ -790,6 +791,20 @@ export interface ComponentDefinition {
|
||||
* ```
|
||||
*/
|
||||
extensionPointProps?: Record<string, any>;
|
||||
|
||||
/**
|
||||
* Extension Point에서 전달받은 콜백 액션 객체
|
||||
*
|
||||
* 백엔드 LayoutExtensionService에서 extension_point 컴포넌트의 callbacks를
|
||||
* 주입된 컴포넌트에 전달할 때 사용됩니다.
|
||||
* extensionPointProps와 달리 표현식 평가 없이 그대로 전달됩니다.
|
||||
* (ActionDispatcher가 실행 시점에 평가)
|
||||
*
|
||||
* 데이터 바인딩에서 {{extensionPointCallbacks.xxx}}로 접근할 수 있습니다.
|
||||
*
|
||||
* @since engine-v1.28.0
|
||||
*/
|
||||
extensionPointCallbacks?: Record<string, any>;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1181,6 +1196,12 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
// _forceLocalInit 강제 초기화 적용 여부 추적 (중복 실행 방지용)
|
||||
const forceInitAppliedRef = useRef<boolean>(false);
|
||||
|
||||
// @since engine-v1.41.0: _localInit useEffect가 처리 완료한 dataContext._localInit 참조를 추적
|
||||
// useMemo(렌더 단계)에서 참조 비교(O(1))로 _localInit 미적용 상태를 감지하여
|
||||
// stale dynamicState(init_actions 기본값의 빈 배열 등)가 dataContext._local의
|
||||
// API 데이터를 덮어쓰는 것을 방지 (플러그인 onMount setLocal 경합 해소)
|
||||
const lastProcessedInitRef = useRef<any>(null);
|
||||
|
||||
// 최신 _local 상태를 참조하는 ref (expandChildren 상태 동기화용)
|
||||
// useCallback으로 캐싱된 componentContext에서도 최신 상태에 접근 가능하도록 함
|
||||
const latestLocalStateRef = useRef<Record<string, any>>({});
|
||||
@@ -1326,6 +1347,11 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
|
||||
logger.log('_localInit applied (data changed):', Object.keys(localInitData));
|
||||
}
|
||||
|
||||
// engine-v1.41.0: _localInit 처리 완료 후 ref 갱신
|
||||
// hash tracking에 의해 shouldApply가 false(skip)된 경우에도 갱신하여
|
||||
// extendedDataContext useMemo가 정상 병합(deepMergeState)을 재개하도록 함
|
||||
lastProcessedInitRef.current = dataContext._localInit;
|
||||
}
|
||||
}, [dataContext._localInit, parentDataContext, bindingEngine]);
|
||||
|
||||
@@ -1514,9 +1540,25 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
// engine-v1.17.4: 비동기 콜백에서 setLocal 호출 시 dynamicState가 stale 값을 가질 수 있음
|
||||
// __g7ForcedLocalFields는 업데이트된 필드만 저장하여, 해당 필드만 우선 적용
|
||||
// 다른 필드의 사용자 입력은 dynamicState에서 보존됨
|
||||
let localState = dataContext._local
|
||||
? deepMergeState(dataContext._local, dynamicState)
|
||||
: dynamicState;
|
||||
// engine-v1.41.0: _localInit이 존재하지만 아직 localDynamicState에 반영되지 않은 경우
|
||||
// stale dynamicState(init_actions 기본값의 빈 배열 등)가 dataContext._local의
|
||||
// API 데이터를 덮어쓰는 것을 방지 (CKEditor 등 플러그인 onMount setLocal 경합 해소)
|
||||
//
|
||||
// 첫 렌더 시 dynamicState는:
|
||||
// - 신규 컴포넌트: { loadingActions: {} } (useState 초기값) → 건너뛰어도 결과 동일
|
||||
// - _fromBase 컴포넌트: 이전 페이지 stale 데이터 → 건너뛰는 것이 정확
|
||||
// dataContext._local은 handleRouteChange에서 init_actions + API 데이터가
|
||||
// 완전히 머지된 상태이므로 단독 사용 시 불완전하지 않음
|
||||
const hasUnappliedInit = dataContext._localInit
|
||||
&& dataContext._localInit !== lastProcessedInitRef.current;
|
||||
let localState: Record<string, any>;
|
||||
if (hasUnappliedInit && dataContext._local) {
|
||||
localState = dataContext._local;
|
||||
} else {
|
||||
localState = dataContext._local
|
||||
? deepMergeState(dataContext._local, dynamicState)
|
||||
: dynamicState;
|
||||
}
|
||||
|
||||
// __g7ForcedLocalFields가 있으면 해당 필드만 최우선으로 병합 (비동기 setLocal fallback 지원)
|
||||
const forcedLocalFields = (window as any).__g7ForcedLocalFields;
|
||||
@@ -1618,11 +1660,23 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
result.$parent = effectiveParentDataContext;
|
||||
}
|
||||
|
||||
// extensionPointProps가 있으면 데이터 컨텍스트에 추가
|
||||
// extensionPointProps가 있으면 데이터 컨텍스트에 추가 (표현식 평가)
|
||||
// extension_point 컴포넌트의 props가 주입된 컴포넌트에서 {{extensionPointProps.xxx}}로 접근 가능
|
||||
// LayoutExtensionService에서 extension_point의 props를 injectedComponent.extensionPointProps에 추가
|
||||
// @since engine-v1.28.0: resolveObject()로 표현식 재귀 평가 (일반 props와 동일 수준)
|
||||
if (componentDef.extensionPointProps) {
|
||||
result.extensionPointProps = componentDef.extensionPointProps;
|
||||
result.extensionPointProps = bindingEngine.resolveObject(
|
||||
componentDef.extensionPointProps,
|
||||
result,
|
||||
isInsideIteration ? { skipCache: true } : undefined
|
||||
);
|
||||
}
|
||||
|
||||
// extensionPointCallbacks가 있으면 데이터 컨텍스트에 추가 (평가 없이 그대로 전달)
|
||||
// 액션 객체는 ActionDispatcher가 실행 시점에 표현식을 평가하므로 사전 평가하면 안 됨
|
||||
// @since engine-v1.28.0
|
||||
if (componentDef.extensionPointCallbacks) {
|
||||
result.extensionPointCallbacks = componentDef.extensionPointCallbacks;
|
||||
}
|
||||
|
||||
return result;
|
||||
@@ -1630,7 +1684,8 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
// effectiveParentDataContext는 동일한 객체 참조를 반환할 수 있으므로
|
||||
// version 변경으로 강제 재계산
|
||||
// componentDef.extensionPointProps: extension_point props 변경 시 재계산
|
||||
}, [dataContext, dynamicState, isolatedContext?.state, effectiveParentDataContext, parentContextHook?.version, componentDef.extensionPointProps]);
|
||||
// componentDef.extensionPointCallbacks: extension_point callbacks 변경 시 재계산
|
||||
}, [dataContext, dynamicState, isolatedContext?.state, effectiveParentDataContext, parentContextHook?.version, componentDef.extensionPointProps, componentDef.extensionPointCallbacks]);
|
||||
|
||||
// 매 렌더링마다 최신 _local 상태를 ref에 업데이트
|
||||
// useCallback으로 캐싱된 componentContext에서도 stateRef.current로 최신 상태 접근 가능
|
||||
@@ -2291,6 +2346,27 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
isInsideIteration,
|
||||
]);
|
||||
|
||||
/**
|
||||
* resolvedProps 참조 안정화 (engine-v1.25.0)
|
||||
*
|
||||
* 상태 변경 시 resolvedProps가 재계산되지만, 해석된 값이 이전과 동일하면
|
||||
* 이전 참조를 반환하여 하위 컴포넌트의 React.memo가 실제로 작동하게 합니다.
|
||||
* shallowObjectEqual은 각 prop 값을 ===로 비교합니다.
|
||||
*
|
||||
* @since engine-v1.25.0
|
||||
*/
|
||||
const previousResolvedPropsRef = useRef<Record<string, any> | null>(null);
|
||||
const stableResolvedProps = useMemo(() => {
|
||||
if (
|
||||
previousResolvedPropsRef.current &&
|
||||
shallowObjectEqual(previousResolvedPropsRef.current, resolvedProps)
|
||||
) {
|
||||
return previousResolvedPropsRef.current;
|
||||
}
|
||||
previousResolvedPropsRef.current = resolvedProps;
|
||||
return resolvedProps;
|
||||
}, [resolvedProps]);
|
||||
|
||||
/**
|
||||
* 자식에게 전달할 FormContext
|
||||
*
|
||||
@@ -2710,6 +2786,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
const itemVar = sortable.itemVar || '$item';
|
||||
const indexVar = sortable.indexVar || '$index';
|
||||
const handle = sortable.handle;
|
||||
const wrapperElement = sortable.wrapperElement;
|
||||
|
||||
/**
|
||||
* 정렬 완료 핸들러
|
||||
@@ -2813,26 +2890,33 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
key={itemTemplateKey}
|
||||
id={itemId}
|
||||
handle={handle}
|
||||
{...(wrapperElement ? { as: wrapperElement } : {})}
|
||||
>
|
||||
<DynamicRenderer
|
||||
componentDef={itemTemplate}
|
||||
dataContext={itemContext}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
parentComponentContext={componentContext}
|
||||
parentFormContextProp={undefined}
|
||||
isInsideIteration={true}
|
||||
isEditMode={isEditMode}
|
||||
onComponentSelect={onComponentSelect}
|
||||
onComponentHover={onComponentHover}
|
||||
componentPath={sortablePath}
|
||||
onDragStart={onDragStart}
|
||||
onDragEnd={onDragEnd}
|
||||
layoutKey={layoutKey}
|
||||
/>
|
||||
{/* wrapperElement 지정 시 itemTemplate의 children을 직접 렌더링 (루트 요소 중복 방지) */}
|
||||
{(wrapperElement && itemTemplate.children ? itemTemplate.children : [itemTemplate]).map(
|
||||
(childDef: any, childIdx: number) => (
|
||||
<DynamicRenderer
|
||||
key={`${itemTemplateKey}-child-${childIdx}`}
|
||||
componentDef={childDef}
|
||||
dataContext={itemContext}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
parentComponentContext={componentContext}
|
||||
parentFormContextProp={undefined}
|
||||
isInsideIteration={true}
|
||||
isEditMode={isEditMode}
|
||||
onComponentSelect={onComponentSelect}
|
||||
onComponentHover={onComponentHover}
|
||||
componentPath={sortablePath}
|
||||
onDragStart={onDragStart}
|
||||
onDragEnd={onDragEnd}
|
||||
layoutKey={layoutKey}
|
||||
/>
|
||||
)
|
||||
)}
|
||||
</SortableItemWrapper>
|
||||
);
|
||||
});
|
||||
@@ -2910,7 +2994,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
devTools.trackMount(componentDef.id, {
|
||||
name: componentDef.name,
|
||||
type: componentDef.type || 'component',
|
||||
props: resolvedProps,
|
||||
props: stableResolvedProps,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -3044,9 +3128,9 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
* 없으면 부모의 FormContext를 그대로 사용합니다.
|
||||
*/
|
||||
const currentFormContext = useMemo<FormContextValue | null>(() => {
|
||||
const dataKey = resolvedProps.dataKey;
|
||||
const trackChanges = resolvedProps.trackChanges;
|
||||
const debounce = resolvedProps.debounce;
|
||||
const dataKey = stableResolvedProps.dataKey;
|
||||
const trackChanges = stableResolvedProps.trackChanges;
|
||||
const debounce = stableResolvedProps.debounce;
|
||||
|
||||
// dataKey가 없으면 null 반환 (FormProvider를 사용하지 않음)
|
||||
if (!dataKey) {
|
||||
@@ -3060,7 +3144,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
setState: handleSetState,
|
||||
state: dynamicState,
|
||||
};
|
||||
}, [resolvedProps.dataKey, resolvedProps.trackChanges, resolvedProps.debounce, handleSetState, dynamicState]);
|
||||
}, [stableResolvedProps.dataKey, stableResolvedProps.trackChanges, stableResolvedProps.debounce, handleSetState, dynamicState]);
|
||||
|
||||
/**
|
||||
* DevTools Form 추적
|
||||
@@ -3072,8 +3156,8 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
* (props 내부가 아님)
|
||||
*/
|
||||
useEffect(() => {
|
||||
// dataKey는 effectiveComponentDef 또는 resolvedProps에서 가져옴
|
||||
const dataKey = (effectiveComponentDef as any).dataKey || resolvedProps.dataKey;
|
||||
// dataKey는 effectiveComponentDef 또는 stableResolvedProps에서 가져옴
|
||||
const dataKey = (effectiveComponentDef as any).dataKey || stableResolvedProps.dataKey;
|
||||
if (!dataKey) return;
|
||||
|
||||
const devToolsForm = getDevTools();
|
||||
@@ -3126,7 +3210,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
return () => {
|
||||
devToolsForm.untrackForm(formId);
|
||||
};
|
||||
}, [effectiveComponentDef, resolvedProps.dataKey, componentDef.id, componentDef.children]);
|
||||
}, [effectiveComponentDef, stableResolvedProps.dataKey, componentDef.id, componentDef.children]);
|
||||
|
||||
/**
|
||||
* 자동 바인딩 debounce 타이머 관리
|
||||
@@ -3154,7 +3238,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
const propsWithAutoBinding = useMemo(() => {
|
||||
// dataKey, trackChanges, debounce는 컴포넌트에 전달하지 않음 (내부 처리용)
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
const { dataKey, trackChanges, debounce, ...propsWithoutFormConfig } = resolvedProps;
|
||||
const { dataKey, trackChanges, debounce, ...propsWithoutFormConfig } = stableResolvedProps;
|
||||
|
||||
// 자동 바인딩 조건 체크
|
||||
const name = propsWithoutFormConfig.name;
|
||||
@@ -3338,7 +3422,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
onChange: autoOnChange,
|
||||
};
|
||||
}
|
||||
}, [resolvedProps, parentFormContext, parentFormContext.state, parentFormContext.debounce]);
|
||||
}, [stableResolvedProps, parentFormContext, parentFormContext.state, parentFormContext.debounce]);
|
||||
|
||||
/**
|
||||
* 메인 렌더링 로직
|
||||
@@ -3506,7 +3590,7 @@ const DynamicRenderer: React.FC<DynamicRendererProps> = memo(
|
||||
|
||||
// dataKey가 있으면 FormProvider로 감싸기
|
||||
// formContextForChildren은 effectiveComponentDef.dataKey를 사용 (componentDef 레벨)
|
||||
// currentFormContext는 resolvedProps.dataKey를 사용하므로 맞지 않음 (props 내부에 dataKey가 없음)
|
||||
// currentFormContext는 stableResolvedProps.dataKey를 사용하므로 맞지 않음 (props 내부에 dataKey가 없음)
|
||||
if (formContextForChildren) {
|
||||
componentElement = (
|
||||
<FormProvider value={formContextForChildren}>
|
||||
|
||||
@@ -1245,6 +1245,19 @@ function initDispatchAPI(G7Core: any): void {
|
||||
_isDispatchFallbackContext: !actionContext?.setState,
|
||||
};
|
||||
|
||||
// engine-v1.41.0: debounce 옵션 처리
|
||||
// ActionDispatcher의 debouncedCall을 사용하여 기존 타이머 인프라 활용
|
||||
if (action.debounce) {
|
||||
const debounceKey = action.debounceKey || `dispatch-${action.handler}`;
|
||||
const delay = typeof action.debounce === 'number' ? action.debounce : action.debounce.delay;
|
||||
actionDispatcher.debouncedCall(debounceKey, delay, () => {
|
||||
// 디바운스 타이머 fire 시 최신 컨텍스트로 액션 실행
|
||||
const { debounce: _d, debounceKey: _k, ...actionWithoutDebounce } = action;
|
||||
actionDispatcher.dispatchAction(actionWithoutDebounce, context);
|
||||
});
|
||||
return { success: true, debounced: true };
|
||||
}
|
||||
|
||||
try {
|
||||
return await actionDispatcher.dispatchAction(action, context);
|
||||
} catch (error) {
|
||||
@@ -1323,6 +1336,49 @@ function hasOnlyNumericKeys(obj: Record<string, any>): boolean {
|
||||
* @param source 병합할 소스 객체
|
||||
* @returns 병합된 결과 객체
|
||||
*/
|
||||
/**
|
||||
* base 객체에 없는 leaf 키만 extra에서 추가합니다.
|
||||
*
|
||||
* deepMerge와 달리 base에 이미 존재하는 값(배열 포함)은 절대 덮어쓰지 않습니다.
|
||||
* extra에만 존재하는 키는 재귀적으로 추가됩니다.
|
||||
*
|
||||
* 용도: setLocal에서 dynamicLocal(actionContext.state)의 setState 전용 키를 globalLocal에
|
||||
* 안전하게 추가할 때 사용. dynamicLocal의 stale 배열(init_actions 기본값)이 globalLocal의
|
||||
* 정상 API 데이터를 덮어쓰는 것을 방지합니다.
|
||||
*
|
||||
* @since engine-v1.41.0
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const base = { form: { category_ids: [381, 384], name: 'A' } };
|
||||
* const extra = { form: { category_ids: [], options: [] }, selectedProducts: [1] };
|
||||
* addMissingLeafKeys(base, extra);
|
||||
* // → { form: { category_ids: [381, 384], name: 'A', options: [] }, selectedProducts: [1] }
|
||||
* // base의 category_ids는 보존, extra의 selectedProducts와 options는 추가
|
||||
* ```
|
||||
*/
|
||||
function addMissingLeafKeys(base: Record<string, any>, extra: Record<string, any>): Record<string, any> {
|
||||
const result = { ...base };
|
||||
for (const key of Object.keys(extra)) {
|
||||
if (!(key in result)) {
|
||||
// base에 없는 키: extra 값 그대로 추가
|
||||
result[key] = extra[key];
|
||||
} else if (
|
||||
result[key] !== null &&
|
||||
typeof result[key] === 'object' &&
|
||||
!Array.isArray(result[key]) &&
|
||||
extra[key] !== null &&
|
||||
typeof extra[key] === 'object' &&
|
||||
!Array.isArray(extra[key])
|
||||
) {
|
||||
// 양쪽 모두 plain object: 재귀적으로 처리
|
||||
result[key] = addMissingLeafKeys(result[key], extra[key]);
|
||||
}
|
||||
// base에 이미 존재하는 leaf 값(배열, 문자열, 숫자 등): 건너뜀 (base 값 보존)
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any> {
|
||||
// 특수 케이스: target이 배열이고 source가 숫자 키만 가진 객체인 경우
|
||||
// → 배열 요소를 인덱스별로 병합
|
||||
@@ -1402,7 +1458,7 @@ function initStateAPI(G7Core: any): void {
|
||||
* @param updates 업데이트할 상태 객체
|
||||
* @param options 병합 옵션 { merge?: 'replace' | 'shallow' | 'deep' }
|
||||
*/
|
||||
set: (updates: Record<string, any>, options?: { merge?: 'replace' | 'shallow' | 'deep' }) => {
|
||||
set: (updates: Record<string, any>, options?: { merge?: 'replace' | 'shallow' | 'deep'; render?: boolean }) => {
|
||||
const templateApp = (window as any).__templateApp;
|
||||
if (templateApp?.setGlobalState && templateApp?.getGlobalState) {
|
||||
const mergeMode = options?.merge || 'deep';
|
||||
@@ -1421,7 +1477,8 @@ function initStateAPI(G7Core: any): void {
|
||||
finalState = deepMerge(currentState, converted);
|
||||
}
|
||||
|
||||
templateApp.setGlobalState(finalState);
|
||||
// engine-v1.42.0: render 옵션 전파
|
||||
templateApp.setGlobalState(finalState, { render: options?.render });
|
||||
} else {
|
||||
logger.warn('G7Core.state.set: TemplateApp이 초기화되지 않았습니다.');
|
||||
}
|
||||
@@ -1467,8 +1524,25 @@ function initStateAPI(G7Core: any): void {
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
setLocal: (updates: Record<string, any>, options?: { scope?: 'current' | 'parent' | 'root'; merge?: 'replace' | 'shallow' | 'deep' }) => {
|
||||
setLocal: (updates: Record<string, any>, options?: { scope?: 'current' | 'parent' | 'root'; merge?: 'replace' | 'shallow' | 'deep'; debounce?: number; debounceKey?: string; render?: boolean }) => {
|
||||
const templateApp = (window as any).__templateApp;
|
||||
|
||||
// engine-v1.41.0: debounce 옵션 처리
|
||||
// ActionDispatcher의 debouncedCall을 사용하여 기존 타이머 인프라 활용
|
||||
// 컴포넌트 언마운트 시 자동 정리 + flushPendingDebounceTimers 연동
|
||||
if (options?.debounce) {
|
||||
const actionDispatcher = templateApp?.getActionDispatcher?.();
|
||||
if (actionDispatcher) {
|
||||
const key = options.debounceKey || `setLocal-${Object.keys(updates).join(',')}`;
|
||||
// 디바운스 타이머 fire 시 원래 setLocal 로직을 debounce 없이 재호출
|
||||
const { debounce: _d, debounceKey: _k, ...restOptions } = options;
|
||||
actionDispatcher.debouncedCall(key, options.debounce, () => {
|
||||
G7Core.state.setLocal(updates, restOptions);
|
||||
});
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const scope = options?.scope ?? 'current';
|
||||
const mergeMode = options?.merge || 'deep';
|
||||
|
||||
@@ -1520,20 +1594,22 @@ function initStateAPI(G7Core: any): void {
|
||||
// globalLocal(=templateApp.getGlobalState()._local)에는 없음.
|
||||
// setLocal 후 openModal 시 __g7PendingLocalState가 $parent._local 스냅샷으로 사용되므로,
|
||||
// dynamicState의 값(예: selectedProducts)이 누락되는 문제 발생.
|
||||
// actionContext.state를 globalLocal과 병합하여 currentSnapshot에 전체 _local을 반영.
|
||||
//
|
||||
// engine-v1.24.7: 모달 내부에서 호출 시 actionContext.state 병합 제외
|
||||
// 모달의 localDynamicState를 globalState._local에 병합하면
|
||||
// 페이지의 dataContext._local이 모달 데이터(cancelItems, refundLoading 등)로 오염됨.
|
||||
// → updateTemplateData 경유 재렌더링 시 페이지 DataGrid 등이 깨지는 버그 발생.
|
||||
// __g7LayoutContextStack에 항목이 있으면 모달이 열린 상태이므로,
|
||||
// actionContext.state는 모달의 localDynamicState → 병합 대상에서 제외.
|
||||
// 페이지 컨텍스트에서만 dynamicLocal을 병합하여 engine-v1.22.1 기능 유지.
|
||||
//
|
||||
// engine-v1.41.0: deepMerge(globalLocal, dynamicLocal)은 stale dynamicLocal의 빈 배열이
|
||||
// globalLocal의 정상 배열을 교체하는 오염 경로를 생성함 (CKEditor + SPA 네비게이션 시 재현).
|
||||
// dynamicLocal은 actionContext.state(=컴포넌트 렌더 시점 스냅샷)이므로
|
||||
// init_actions 기본값(category_ids:[], options:[])을 포함할 수 있음.
|
||||
// globalLocal은 최신 committed 상태이므로 dynamicLocal과 충돌 시 globalLocal이 정확함.
|
||||
// → globalLocal을 기반으로 dynamicLocal에서 globalLocal에 없는 키만 추가하는
|
||||
// addMissingLeafKeys 전략으로 변경. v1.22.1 목적(setState 전용 키 보존)은 유지하면서
|
||||
// stale 배열 덮어쓰기 방지.
|
||||
const layoutContextStack = (window as any).__g7LayoutContextStack || [];
|
||||
const isInsideModal = layoutContextStack.length > 0;
|
||||
const dynamicLocal = (!isInsideModal && actionContext?.state) ? actionContext.state : undefined;
|
||||
const baseLocal = dynamicLocal
|
||||
? deepMerge(globalLocal, dynamicLocal)
|
||||
? addMissingLeafKeys(globalLocal, dynamicLocal)
|
||||
: globalLocal;
|
||||
const currentSnapshot = pendingState || baseLocal;
|
||||
let mergedPending: Record<string, any>;
|
||||
@@ -1546,9 +1622,10 @@ function initStateAPI(G7Core: any): void {
|
||||
}
|
||||
|
||||
// 1. 전역 _local 상태 업데이트 (핵심!)
|
||||
// engine-v1.42.0: render 옵션 전파 — render: false이면 값만 저장, React 렌더링 건너뜀
|
||||
if (templateApp?.setGlobalState) {
|
||||
templateApp.setGlobalState({ _local: mergedPending });
|
||||
logger.log(`[setLocal] globalLocal updated via setGlobalState (mergeMode=${mergeMode}):`, converted);
|
||||
templateApp.setGlobalState({ _local: mergedPending }, { render: options?.render });
|
||||
logger.log(`[setLocal] globalLocal updated via setGlobalState (mergeMode=${mergeMode}, render=${options?.render ?? true}):`, converted);
|
||||
}
|
||||
|
||||
// 2. pendingState도 업데이트 (같은 이벤트 루프 내 후속 getLocal() 호출용)
|
||||
@@ -2665,10 +2742,14 @@ function initCoreAPIs(G7Core: any, deps: G7CoreDependencies): void {
|
||||
|
||||
// updateQueryParams 노출 (같은 페이지 내 쿼리 변경 시 컴포넌트 리마운트 없이 데이터 갱신)
|
||||
// navigate 핸들러에서 replace: true 사용 시 자동 호출됨
|
||||
G7Core.updateQueryParams = async (newPath: string) => {
|
||||
// options.transitionOverlayTarget: 호출별 transition_overlay.target 동적 override (@since engine-v1.36.0)
|
||||
G7Core.updateQueryParams = async (
|
||||
newPath: string,
|
||||
options?: { transitionOverlayTarget?: string }
|
||||
) => {
|
||||
const templateApp = (window as any).__templateApp;
|
||||
if (templateApp?.updateQueryParams) {
|
||||
return templateApp.updateQueryParams(newPath);
|
||||
return templateApp.updateQueryParams(newPath, options);
|
||||
}
|
||||
logger.warn('G7Core.updateQueryParams: TemplateApp이 초기화되지 않았습니다.');
|
||||
};
|
||||
|
||||
@@ -321,6 +321,20 @@ export interface LayoutData {
|
||||
/** 커스텀 로딩 텍스트 (미지정 시 nav.loading 번역 키 사용) */
|
||||
text?: string;
|
||||
};
|
||||
/**
|
||||
* spinner 가 표시되어야 할 데이터소스 ID 목록
|
||||
*
|
||||
* blocking 데이터소스가 없는 페이지에서도 명시된 progressive 데이터소스가
|
||||
* fetch 완료될 때까지 transition_overlay 가 표시됩니다.
|
||||
*
|
||||
* 호환되는 loading_strategy: blocking, progressive
|
||||
* 자동 무시되는 케이스: background, websocket, 존재하지 않는 ID
|
||||
*
|
||||
* 백엔드 검증(UpdateLayoutContentRequest)에서 background/websocket ID 는 사전 차단됩니다.
|
||||
*
|
||||
* @since engine-v1.30.0
|
||||
*/
|
||||
wait_for?: string[];
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@@ -164,13 +164,21 @@ export class TranslationEngine {
|
||||
* 새로운 다국어 데이터를 서버에서 가져오도록 합니다.
|
||||
*
|
||||
* @param version 캐시 버전 (타임스탬프)
|
||||
*
|
||||
* @since engine-v1.38.1 활성 `translations` 맵은 비우지 않음 — 이전에는
|
||||
* `clearCache()` 로 `translations` 까지 비웠기 때문에, `reloadExtensions`
|
||||
* 와 같은 병렬 재동기화 중 새 `loadTranslations()` 가 끝나기 전에 실행되는
|
||||
* `translate()` 호출이 빈 사전을 만나 raw $t:key 를 반환하는 경합이 있었음.
|
||||
* 이제 TTL 캐시(`this.cache`)만 비우고, 활성 사전(`this.translations`)은
|
||||
* `loadTranslations` 가 새 데이터를 `set()` 으로 원자 교체할 때까지 유지된다.
|
||||
*/
|
||||
setCacheVersion(version: number): void {
|
||||
if (this.cacheVersion !== version) {
|
||||
logger.log('Cache version updated:', this.cacheVersion, '->', version);
|
||||
this.cacheVersion = version;
|
||||
// 캐시 버전 변경 시 기존 캐시 클리어 (새 버전으로 로드 필요)
|
||||
this.clearCache();
|
||||
// TTL 캐시만 클리어 → getFromCache 미스 → 다음 loadTranslations 가 새 버전 URL 로 fetch.
|
||||
// 활성 translations 맵은 fetch 완료 시 원자적으로 교체되므로 건드리지 않음.
|
||||
this.cache.clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+180
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* ActionDispatcher handleNavigate fallback 테스트
|
||||
*
|
||||
* 미등록 라우트로 navigate 시 fallback 핸들러(기본 openWindow)로 분기 검증.
|
||||
*
|
||||
* @since engine-v1.40.0
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { ActionDispatcher } from '../ActionDispatcher';
|
||||
import { Logger } from '../../utils/Logger';
|
||||
|
||||
vi.mock('../../auth/AuthManager', () => ({
|
||||
AuthManager: {
|
||||
getInstance: vi.fn(() => ({
|
||||
login: vi.fn(),
|
||||
logout: vi.fn(),
|
||||
})),
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock('../../api/ApiClient', () => ({
|
||||
getApiClient: vi.fn(() => ({
|
||||
getToken: vi.fn(),
|
||||
})),
|
||||
}));
|
||||
|
||||
describe('ActionDispatcher - handleNavigate fallback (engine-v1.40.0)', () => {
|
||||
let dispatcher: ActionDispatcher;
|
||||
let mockNavigate: ReturnType<typeof vi.fn>;
|
||||
let mockMatch: ReturnType<typeof vi.fn>;
|
||||
let mockWindowOpen: ReturnType<typeof vi.fn>;
|
||||
let originalWindowOpen: typeof window.open;
|
||||
|
||||
beforeEach(() => {
|
||||
mockNavigate = vi.fn();
|
||||
dispatcher = new ActionDispatcher({ navigate: mockNavigate });
|
||||
Logger.getInstance().setDebug(false);
|
||||
|
||||
mockMatch = vi.fn();
|
||||
(window as any).__templateApp = {
|
||||
getRouter: () => ({
|
||||
match: mockMatch,
|
||||
}),
|
||||
};
|
||||
|
||||
originalWindowOpen = window.open;
|
||||
mockWindowOpen = vi.fn();
|
||||
window.open = mockWindowOpen as any;
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
window.open = originalWindowOpen;
|
||||
delete (window as any).__templateApp;
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
it('라우트 매칭 성공 시 정상 navigate — fallback 미호출', async () => {
|
||||
mockMatch.mockReturnValue({ route: { path: '/admin/users' }, params: {} });
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/admin/users' },
|
||||
});
|
||||
|
||||
expect(mockMatch).toHaveBeenCalledWith('/admin/users');
|
||||
expect(mockNavigate).toHaveBeenCalledWith('/admin/users', { replace: false });
|
||||
expect(mockWindowOpen).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('라우트 매칭 실패 + fallback 미지정 → 기본 openWindow', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/shop/orders/123' },
|
||||
});
|
||||
|
||||
expect(mockNavigate).not.toHaveBeenCalled();
|
||||
expect(mockWindowOpen).toHaveBeenCalledWith('/shop/orders/123', '_blank');
|
||||
});
|
||||
|
||||
it('라우트 매칭 실패 + fallback: false → 기존 동작(navigate 강행)', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/shop/orders/123', fallback: false },
|
||||
});
|
||||
|
||||
expect(mockNavigate).toHaveBeenCalledWith('/shop/orders/123', { replace: false });
|
||||
expect(mockWindowOpen).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('라우트 매칭 실패 + fallback: string → 해당 핸들러로 분기', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/shop/orders/123', fallback: 'openWindow' },
|
||||
});
|
||||
|
||||
expect(mockNavigate).not.toHaveBeenCalled();
|
||||
expect(mockWindowOpen).toHaveBeenCalledWith('/shop/orders/123', '_blank');
|
||||
});
|
||||
|
||||
it('라우트 매칭 실패 + fallback: { handler, params } → 상세 지정 동작', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: {
|
||||
path: '/shop/orders/123',
|
||||
fallback: { handler: 'openWindow', params: { target: '_blank' } },
|
||||
},
|
||||
});
|
||||
|
||||
expect(mockNavigate).not.toHaveBeenCalled();
|
||||
expect(mockWindowOpen).toHaveBeenCalledWith('/shop/orders/123', '_blank');
|
||||
});
|
||||
|
||||
it('쿼리 파라미터가 있는 경로도 fallback pathname만 매칭', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: {
|
||||
path: '/shop/orders',
|
||||
query: { id: '123', tab: 'detail' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(mockMatch).toHaveBeenCalledWith('/shop/orders');
|
||||
expect(mockNavigate).not.toHaveBeenCalled();
|
||||
// query가 병합된 finalPath가 openWindow로 전달됨
|
||||
expect(mockWindowOpen).toHaveBeenCalled();
|
||||
const openedUrl = mockWindowOpen.mock.calls[0][0];
|
||||
expect(openedUrl).toContain('/shop/orders?');
|
||||
expect(openedUrl).toContain('id=123');
|
||||
expect(openedUrl).toContain('tab=detail');
|
||||
});
|
||||
|
||||
it('replace: true 경로는 fallback 미적용 (쿼리 갱신 전용)', async () => {
|
||||
mockMatch.mockReturnValue(null);
|
||||
(window as any).G7Core = {
|
||||
updateQueryParams: vi.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/admin/users', query: { page: 2 }, replace: true },
|
||||
});
|
||||
|
||||
// replace 경로는 updateQueryParams 사용 — fallback 미적용
|
||||
expect((window as any).G7Core.updateQueryParams).toHaveBeenCalled();
|
||||
expect(mockWindowOpen).not.toHaveBeenCalled();
|
||||
|
||||
delete (window as any).G7Core;
|
||||
});
|
||||
|
||||
it('router를 가져올 수 없으면 fallback 미적용 (정상 navigate)', async () => {
|
||||
(window as any).__templateApp = undefined;
|
||||
|
||||
await dispatcher.dispatchAction({
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params: { path: '/shop/orders/123' },
|
||||
});
|
||||
|
||||
expect(mockNavigate).toHaveBeenCalledWith('/shop/orders/123', { replace: false });
|
||||
expect(mockWindowOpen).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* ActionDispatcher.reloadExtensions 테스트 (engine-v1.19.0)
|
||||
*
|
||||
* 확장 라이프사이클(install/activate/deactivate/uninstall) 직후 호출되는
|
||||
* `reloadExtensions` 통합 핸들러 및 하위 호환 핸들러(`reloadRoutes`, `reloadTranslations`)의
|
||||
* TemplateApp.reloadExtensionState() 위임 동작을 검증합니다.
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { ActionDispatcher, ActionDefinition, ActionContext } from '../ActionDispatcher';
|
||||
|
||||
vi.mock('../../auth/AuthManager', () => ({
|
||||
AuthManager: {
|
||||
getInstance: vi.fn(() => ({
|
||||
login: vi.fn(),
|
||||
logout: vi.fn(),
|
||||
})),
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock('../../api/ApiClient', () => ({
|
||||
getApiClient: vi.fn(() => ({ getToken: vi.fn() })),
|
||||
}));
|
||||
|
||||
describe('ActionDispatcher.reloadExtensions (engine-v1.19.0)', () => {
|
||||
let dispatcher: ActionDispatcher;
|
||||
let reloadExtensionState: ReturnType<typeof vi.fn>;
|
||||
|
||||
beforeEach(() => {
|
||||
dispatcher = new ActionDispatcher({ navigate: vi.fn() });
|
||||
reloadExtensionState = vi.fn().mockResolvedValue(undefined);
|
||||
|
||||
(globalThis as any).window = globalThis as any;
|
||||
(globalThis as any).__templateApp = {
|
||||
reloadExtensionState,
|
||||
getRouter: vi.fn(() => ({ loadRoutes: vi.fn() })),
|
||||
getConfig: vi.fn(() => ({ templateId: 'sirsoft-admin_basic', locale: 'ko' })),
|
||||
};
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
delete (globalThis as any).__templateApp;
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
const context: ActionContext = { props: {}, event: null as any };
|
||||
|
||||
it('reloadExtensions 는 TemplateApp.reloadExtensionState 를 호출해야 합니다', async () => {
|
||||
await dispatcher.dispatchAction({ handler: 'reloadExtensions' } as ActionDefinition, context);
|
||||
expect(reloadExtensionState).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('reloadRoutes 는 TemplateApp.reloadExtensionState 로 위임해야 합니다 (하위 호환)', async () => {
|
||||
await dispatcher.dispatchAction({ handler: 'reloadRoutes' } as ActionDefinition, context);
|
||||
expect(reloadExtensionState).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('reloadTranslations 는 TemplateApp.reloadExtensionState 로 위임해야 합니다 (하위 호환)', async () => {
|
||||
await dispatcher.dispatchAction({ handler: 'reloadTranslations' } as ActionDefinition, context);
|
||||
expect(reloadExtensionState).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('TemplateApp 이 초기화되지 않았으면 에러 없이 경고 후 반환해야 합니다', async () => {
|
||||
delete (globalThis as any).__templateApp;
|
||||
await expect(
|
||||
dispatcher.dispatchAction({ handler: 'reloadExtensions' } as ActionDefinition, context)
|
||||
).resolves.not.toThrow();
|
||||
expect(reloadExtensionState).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -743,6 +743,417 @@ describe('ActionDispatcher', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('navigate scroll 옵션 (engine-v1.37.0)', () => {
|
||||
let scrollToSpy: ReturnType<typeof vi.fn>;
|
||||
let rafSpy: any;
|
||||
let originalScrollTo: typeof window.scrollTo;
|
||||
let originalReplaceState: typeof window.history.replaceState;
|
||||
|
||||
beforeEach(() => {
|
||||
originalScrollTo = window.scrollTo;
|
||||
originalReplaceState = window.history.replaceState;
|
||||
|
||||
scrollToSpy = vi.fn();
|
||||
Object.defineProperty(window, 'scrollTo', {
|
||||
value: scrollToSpy,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
// requestAnimationFrame을 동기 실행으로 변환
|
||||
rafSpy = vi
|
||||
.spyOn(window, 'requestAnimationFrame')
|
||||
.mockImplementation((cb: FrameRequestCallback) => {
|
||||
cb(0);
|
||||
return 0;
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rafSpy.mockRestore();
|
||||
Object.defineProperty(window, 'scrollTo', {
|
||||
value: originalScrollTo,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
Object.defineProperty(window.history, 'replaceState', {
|
||||
value: originalReplaceState,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
delete (window as any).G7Core;
|
||||
});
|
||||
|
||||
const triggerNavigate = async (params: Record<string, any>) => {
|
||||
const action: ActionDefinition = {
|
||||
type: 'click',
|
||||
handler: 'navigate',
|
||||
params,
|
||||
};
|
||||
const handler = dispatcher.createHandler(action);
|
||||
const mockEvent = {
|
||||
preventDefault: vi.fn(),
|
||||
type: 'click',
|
||||
target: null,
|
||||
} as unknown as Event;
|
||||
await handler(mockEvent);
|
||||
};
|
||||
|
||||
it('기본 동작: navigate 후 상단으로 스크롤해야 함 (scroll 미지정)', async () => {
|
||||
await triggerNavigate({ path: '/admin/users' });
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
it('scroll: "top" 명시 시 상단으로 스크롤해야 함', async () => {
|
||||
await triggerNavigate({ path: '/admin/users', scroll: 'top' });
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
it('scroll: "preserve" 시 스크롤을 건드리지 않아야 함', async () => {
|
||||
await triggerNavigate({ path: '/admin/users', scroll: 'preserve' });
|
||||
|
||||
expect(scrollToSpy).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('scroll: number 시 해당 Y 좌표로 스크롤해야 함', async () => {
|
||||
await triggerNavigate({ path: '/admin/users', scroll: 200 });
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 200,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
it('scroll: { x, y } 객체 시 해당 좌표로 스크롤해야 함', async () => {
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: { x: 10, y: 300 },
|
||||
});
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 300,
|
||||
left: 10,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
it('scrollBehavior: "smooth" 지정 시 smooth 전달', async () => {
|
||||
await triggerNavigate({ path: '/admin/users', scrollBehavior: 'smooth' });
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'smooth',
|
||||
});
|
||||
});
|
||||
|
||||
it('scroll: "#selector" 시 해당 엘리먼트로 scrollIntoView 호출', async () => {
|
||||
const mockEl = document.createElement('div');
|
||||
mockEl.id = 'target-section';
|
||||
const scrollIntoViewSpy = vi.fn();
|
||||
(mockEl as any).scrollIntoView = scrollIntoViewSpy;
|
||||
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockReturnValue(mockEl);
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: '#target-section',
|
||||
});
|
||||
|
||||
expect(querySelectorSpy).toHaveBeenCalledWith('#target-section');
|
||||
expect(scrollIntoViewSpy).toHaveBeenCalledWith({
|
||||
behavior: 'instant',
|
||||
block: 'start',
|
||||
});
|
||||
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('replace: true (updateQueryParams) 경로에서도 기본 상단 스크롤 적용', async () => {
|
||||
const updateQueryParamsSpy = vi.fn().mockResolvedValue(undefined);
|
||||
(window as any).G7Core = { updateQueryParams: updateQueryParamsSpy };
|
||||
|
||||
await triggerNavigate({ path: '/admin/users', replace: true });
|
||||
|
||||
expect(updateQueryParamsSpy).toHaveBeenCalled();
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
|
||||
delete (window as any).G7Core;
|
||||
});
|
||||
|
||||
it('replaceUrl 핸들러 기본값은 preserve여야 함', async () => {
|
||||
const replaceStateSpy = vi.fn();
|
||||
Object.defineProperty(window.history, 'replaceState', {
|
||||
value: replaceStateSpy,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const action: ActionDefinition = {
|
||||
type: 'click',
|
||||
handler: 'replaceUrl',
|
||||
params: { path: '/admin/users?selected=42' },
|
||||
};
|
||||
const handler = dispatcher.createHandler(action);
|
||||
await handler({
|
||||
preventDefault: vi.fn(),
|
||||
type: 'click',
|
||||
target: null,
|
||||
} as unknown as Event);
|
||||
|
||||
expect(replaceStateSpy).toHaveBeenCalled();
|
||||
expect(scrollToSpy).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('replaceUrl 핸들러에 scroll: "top" 명시 시 상단 이동', async () => {
|
||||
Object.defineProperty(window.history, 'replaceState', {
|
||||
value: vi.fn(),
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const action: ActionDefinition = {
|
||||
type: 'click',
|
||||
handler: 'replaceUrl',
|
||||
params: { path: '/admin/users', scroll: 'top' },
|
||||
};
|
||||
const handler = dispatcher.createHandler(action);
|
||||
await handler({
|
||||
preventDefault: vi.fn(),
|
||||
type: 'click',
|
||||
target: null,
|
||||
} as unknown as Event);
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
describe('확장 객체 문법 (container/to/block/offset)', () => {
|
||||
it('container + to: number → 지정 컨테이너에 Y 좌표로 스크롤', async () => {
|
||||
const containerEl = document.createElement('div');
|
||||
containerEl.id = 'right_content_area';
|
||||
const containerScrollTo = vi.fn();
|
||||
(containerEl as any).scrollTo = containerScrollTo;
|
||||
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockImplementation((sel: string) =>
|
||||
sel === '#right_content_area' ? containerEl : null
|
||||
);
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: {
|
||||
container: '#right_content_area',
|
||||
to: 250,
|
||||
},
|
||||
});
|
||||
|
||||
expect(containerScrollTo).toHaveBeenCalledWith({
|
||||
top: 250,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
// window 는 스크롤되지 않아야 함 (컨테이너 지정 시)
|
||||
expect(scrollToSpy).not.toHaveBeenCalled();
|
||||
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('container + to: "top" → 지정 컨테이너를 상단으로', async () => {
|
||||
const containerEl = document.createElement('div');
|
||||
const containerScrollTo = vi.fn();
|
||||
(containerEl as any).scrollTo = containerScrollTo;
|
||||
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockReturnValue(containerEl);
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: { container: '#right_content_area', to: 'top' },
|
||||
});
|
||||
|
||||
expect(containerScrollTo).toHaveBeenCalledWith({
|
||||
top: 0,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('container + to: "#element" + offset → 엘리먼트를 컨테이너 안에서 offset 만큼 위로 보정', async () => {
|
||||
const containerEl = document.createElement('div');
|
||||
containerEl.id = 'scroll_area';
|
||||
const containerScrollTo = vi.fn();
|
||||
(containerEl as any).scrollTo = containerScrollTo;
|
||||
// 컨테이너 위치/크기 모킹
|
||||
(containerEl as any).getBoundingClientRect = () => ({
|
||||
top: 0,
|
||||
left: 0,
|
||||
right: 800,
|
||||
bottom: 600,
|
||||
width: 800,
|
||||
height: 600,
|
||||
});
|
||||
Object.defineProperty(containerEl, 'scrollTop', { value: 0, configurable: true });
|
||||
Object.defineProperty(containerEl, 'clientHeight', { value: 600, configurable: true });
|
||||
|
||||
const targetEl = document.createElement('div');
|
||||
targetEl.id = 'section';
|
||||
(targetEl as any).getBoundingClientRect = () => ({
|
||||
top: 400,
|
||||
left: 0,
|
||||
right: 800,
|
||||
bottom: 450,
|
||||
width: 800,
|
||||
height: 50,
|
||||
});
|
||||
Object.defineProperty(targetEl, 'clientHeight', { value: 50, configurable: true });
|
||||
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockImplementation((sel: string) => {
|
||||
if (sel === '#scroll_area') return containerEl;
|
||||
if (sel === '#section') return targetEl;
|
||||
return null;
|
||||
});
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: {
|
||||
container: '#scroll_area',
|
||||
to: '#section',
|
||||
offset: 80,
|
||||
},
|
||||
});
|
||||
|
||||
// relativeTop = 0 + (400 - 0) = 400, block=start, offset=80
|
||||
// top = 400 - 80 = 320
|
||||
expect(containerScrollTo).toHaveBeenCalledWith({
|
||||
top: 320,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('container + to: "#element" + block: "center" → 엘리먼트를 컨테이너 중앙에 위치', async () => {
|
||||
const containerEl = document.createElement('div');
|
||||
const containerScrollTo = vi.fn();
|
||||
(containerEl as any).scrollTo = containerScrollTo;
|
||||
(containerEl as any).getBoundingClientRect = () => ({
|
||||
top: 0,
|
||||
left: 0,
|
||||
right: 800,
|
||||
bottom: 600,
|
||||
width: 800,
|
||||
height: 600,
|
||||
});
|
||||
Object.defineProperty(containerEl, 'scrollTop', { value: 0, configurable: true });
|
||||
Object.defineProperty(containerEl, 'clientHeight', { value: 600, configurable: true });
|
||||
|
||||
const targetEl = document.createElement('div');
|
||||
(targetEl as any).getBoundingClientRect = () => ({
|
||||
top: 400,
|
||||
left: 0,
|
||||
right: 800,
|
||||
bottom: 500,
|
||||
width: 800,
|
||||
height: 100,
|
||||
});
|
||||
Object.defineProperty(targetEl, 'clientHeight', { value: 100, configurable: true });
|
||||
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockImplementation((sel: string) => {
|
||||
if (sel === '#scroll_area') return containerEl;
|
||||
if (sel === '#section') return targetEl;
|
||||
return null;
|
||||
});
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: {
|
||||
container: '#scroll_area',
|
||||
to: '#section',
|
||||
block: 'center',
|
||||
},
|
||||
});
|
||||
|
||||
// relativeTop = 400, block=center → top = 400 - (600 - 100)/2 = 400 - 250 = 150
|
||||
expect(containerScrollTo).toHaveBeenCalledWith({
|
||||
top: 150,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('확장 객체 (container 생략) + to: number → window 스크롤', async () => {
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: { to: 500 },
|
||||
});
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 500,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
|
||||
it('container 미발견 시 경고 로그 후 no-op', async () => {
|
||||
const querySelectorSpy = vi
|
||||
.spyOn(document, 'querySelector')
|
||||
.mockReturnValue(null);
|
||||
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: { container: '#nonexistent', to: 'top' },
|
||||
});
|
||||
|
||||
expect(scrollToSpy).not.toHaveBeenCalled();
|
||||
querySelectorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('offset 지정 시 Y 좌표에서 차감', async () => {
|
||||
await triggerNavigate({
|
||||
path: '/admin/users',
|
||||
scroll: { to: 500, offset: 80 },
|
||||
});
|
||||
|
||||
expect(scrollToSpy).toHaveBeenCalledWith({
|
||||
top: 420,
|
||||
left: 0,
|
||||
behavior: 'instant',
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('커스텀 콜백 이벤트 (onSortChange, onSelectionChange 등)', () => {
|
||||
it('커스텀 콜백 이벤트의 여러 인자를 $args 배열로 전달해야 함', () => {
|
||||
const mockSetState = vi.fn();
|
||||
|
||||
@@ -453,6 +453,37 @@ describe('DataBindingEngine', () => {
|
||||
const result = engine.evaluateExpression('flag ? $t:sirsoft-board.admin.key1 : $t:sirsoft-board.admin.key2', context);
|
||||
expect(result).toBe('$t:sirsoft-board.admin.key2');
|
||||
});
|
||||
|
||||
// @since engine-v1.38.2
|
||||
// 회귀 방지: action context 가 $templateId 를 누락한 경우에도
|
||||
// window.__templateApp.getConfig() 로부터 회수하여 $t() 가 정상 동작해야 한다.
|
||||
// (admin_module_list 토스트가 raw key 를 노출하던 버그)
|
||||
it('$templateId 누락 시 window.__templateApp.getConfig() 로부터 fallback', async () => {
|
||||
const { TranslationEngine } = await import('../TranslationEngine');
|
||||
const te = TranslationEngine.getInstance();
|
||||
// 테스트 격리: 직접 translations 맵에 데이터 주입
|
||||
(te as any).translations.set('sirsoft-admin_basic:ko', {
|
||||
admin: { modules: { activate_success: '모듈 활성화 성공' } },
|
||||
});
|
||||
|
||||
const originalTemplateApp = (globalThis as any).__templateApp;
|
||||
(globalThis as any).__templateApp = {
|
||||
getConfig: () => ({ templateId: 'sirsoft-admin_basic', locale: 'ko' }),
|
||||
};
|
||||
|
||||
try {
|
||||
// action context 에는 $templateId 가 없음 (실제 dispatchAction 컨텍스트 시뮬레이션)
|
||||
const context = { $event: { target: { checked: true } } };
|
||||
const result = engine.evaluateExpression(
|
||||
"$event.target.checked ? '$t:admin.modules.activate_success' : '$t:admin.modules.deactivate_success'",
|
||||
context
|
||||
);
|
||||
expect(result).toBe('모듈 활성화 성공');
|
||||
} finally {
|
||||
(globalThis as any).__templateApp = originalTemplateApp;
|
||||
(te as any).translations.delete('sirsoft-admin_basic:ko');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('$localized 헬퍼 함수', () => {
|
||||
|
||||
@@ -28,6 +28,18 @@ vi.mock('../../api/ApiClient', () => ({
|
||||
getApiClient: vi.fn(() => mockApiClientInstance),
|
||||
}));
|
||||
|
||||
// AuthManager 모킹 (기본: 인증된 상태)
|
||||
// engine-v1.32.1: auth_required: true 데이터소스는 토큰이 없으면 요청을 스킵하므로
|
||||
// auth_required: true 케이스를 검증하려면 인증된 상태로 모킹해야 함
|
||||
const mockIsAuthenticated = vi.fn(() => true);
|
||||
vi.mock('../../auth/AuthManager', () => ({
|
||||
AuthManager: {
|
||||
getInstance: vi.fn(() => ({
|
||||
isAuthenticated: mockIsAuthenticated,
|
||||
})),
|
||||
},
|
||||
}));
|
||||
|
||||
// fetch 모킹
|
||||
global.fetch = vi.fn();
|
||||
|
||||
|
||||
@@ -27,6 +27,16 @@ vi.mock('../../api/ApiClient', () => ({
|
||||
getApiClient: vi.fn(() => mockApiClientInstance),
|
||||
}));
|
||||
|
||||
// AuthManager 모킹 (기본: 인증된 상태)
|
||||
const mockIsAuthenticated = vi.fn(() => true);
|
||||
vi.mock('../../auth/AuthManager', () => ({
|
||||
AuthManager: {
|
||||
getInstance: vi.fn(() => ({
|
||||
isAuthenticated: mockIsAuthenticated,
|
||||
})),
|
||||
},
|
||||
}));
|
||||
|
||||
// ErrorHandlingResolver 모킹
|
||||
const mockResolverExecute = vi.fn();
|
||||
const mockResolverResolve = vi.fn(() => ({
|
||||
@@ -1066,4 +1076,145 @@ describe('DataSourceManager', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('auth_mode: required + 토큰 없을 때 요청 스킵', () => {
|
||||
it('auth_required: true이고 토큰이 없으면 요청을 스킵하고 fallback을 사용해야 함', async () => {
|
||||
// 비인증 상태 설정
|
||||
mockIsAuthenticated.mockReturnValue(false);
|
||||
|
||||
const sources: DataSource[] = [
|
||||
{
|
||||
id: 'notifications',
|
||||
type: 'api',
|
||||
endpoint: '/api/user/notifications/unread-count',
|
||||
method: 'GET',
|
||||
auto_fetch: true,
|
||||
auth_required: true,
|
||||
loading_strategy: 'progressive',
|
||||
fallback: { data: { unread_count: 0 } },
|
||||
},
|
||||
];
|
||||
|
||||
const results = await manager.fetchDataSources(sources, {});
|
||||
|
||||
// API 호출이 일어나지 않아야 함
|
||||
expect(mockApiClientInstance.get).not.toHaveBeenCalled();
|
||||
expect(global.fetch).not.toHaveBeenCalled();
|
||||
|
||||
// fallback 데이터가 사용되어야 함
|
||||
expect(results.notifications).toEqual({ data: { unread_count: 0 } });
|
||||
|
||||
// 인증 상태 복원
|
||||
mockIsAuthenticated.mockReturnValue(true);
|
||||
});
|
||||
|
||||
it('auth_mode: "required"이고 토큰이 없으면 요청을 스킵하고 fallback을 사용해야 함', async () => {
|
||||
mockIsAuthenticated.mockReturnValue(false);
|
||||
|
||||
const sources: DataSource[] = [
|
||||
{
|
||||
id: 'user_data',
|
||||
type: 'api',
|
||||
endpoint: '/api/user/profile',
|
||||
method: 'GET',
|
||||
auto_fetch: true,
|
||||
auth_mode: 'required',
|
||||
loading_strategy: 'progressive',
|
||||
fallback: { data: null },
|
||||
},
|
||||
];
|
||||
|
||||
const results = await manager.fetchDataSources(sources, {});
|
||||
|
||||
expect(mockApiClientInstance.get).not.toHaveBeenCalled();
|
||||
expect(global.fetch).not.toHaveBeenCalled();
|
||||
expect(results.user_data).toEqual({ data: null });
|
||||
|
||||
mockIsAuthenticated.mockReturnValue(true);
|
||||
});
|
||||
|
||||
it('auth_required: true이고 토큰이 없고 fallback이 없으면 에러 상태여야 함', async () => {
|
||||
mockIsAuthenticated.mockReturnValue(false);
|
||||
|
||||
const sources: DataSource[] = [
|
||||
{
|
||||
id: 'secure_data',
|
||||
type: 'api',
|
||||
endpoint: '/api/admin/data',
|
||||
method: 'GET',
|
||||
auto_fetch: true,
|
||||
auth_required: true,
|
||||
loading_strategy: 'progressive',
|
||||
},
|
||||
];
|
||||
|
||||
const results = await manager.fetchDataSources(sources, {});
|
||||
|
||||
// API 호출이 일어나지 않아야 함
|
||||
expect(mockApiClientInstance.get).not.toHaveBeenCalled();
|
||||
expect(global.fetch).not.toHaveBeenCalled();
|
||||
|
||||
// fallback 없으므로 결과에 데이터가 없어야 함
|
||||
expect(results.secure_data).toBeUndefined();
|
||||
|
||||
mockIsAuthenticated.mockReturnValue(true);
|
||||
});
|
||||
|
||||
it('auth_required: true이고 토큰이 있으면 정상적으로 API를 호출해야 함', async () => {
|
||||
mockIsAuthenticated.mockReturnValue(true);
|
||||
|
||||
const mockResponse = { data: { unread_count: 5 } };
|
||||
mockApiClientInstance.get.mockResolvedValue(mockResponse);
|
||||
|
||||
const sources: DataSource[] = [
|
||||
{
|
||||
id: 'notifications',
|
||||
type: 'api',
|
||||
endpoint: '/api/user/notifications/unread-count',
|
||||
method: 'GET',
|
||||
auto_fetch: true,
|
||||
auth_required: true,
|
||||
loading_strategy: 'progressive',
|
||||
fallback: { data: { unread_count: 0 } },
|
||||
},
|
||||
];
|
||||
|
||||
const results = await manager.fetchDataSources(sources, {});
|
||||
|
||||
// API 호출이 발생해야 함
|
||||
expect(mockApiClientInstance.get).toHaveBeenCalled();
|
||||
expect(results.notifications).toEqual(mockResponse);
|
||||
});
|
||||
|
||||
it('auth_mode: "optional"이고 토큰이 없으면 일반 fetch로 요청해야 함 (스킵하지 않음)', async () => {
|
||||
mockIsAuthenticated.mockReturnValue(false);
|
||||
|
||||
const mockResponse = { data: { count: 3 } };
|
||||
(global.fetch as any).mockResolvedValue({
|
||||
ok: true,
|
||||
json: async () => mockResponse,
|
||||
});
|
||||
|
||||
const sources: DataSource[] = [
|
||||
{
|
||||
id: 'cart',
|
||||
type: 'api',
|
||||
endpoint: '/api/cart',
|
||||
method: 'GET',
|
||||
auto_fetch: true,
|
||||
auth_mode: 'optional',
|
||||
loading_strategy: 'progressive',
|
||||
},
|
||||
];
|
||||
|
||||
const results = await manager.fetchDataSources(sources, {});
|
||||
|
||||
// ApiClient가 아닌 일반 fetch가 사용되어야 함
|
||||
expect(mockApiClientInstance.get).not.toHaveBeenCalled();
|
||||
expect(global.fetch).toHaveBeenCalled();
|
||||
expect(results.cart).toEqual(mockResponse);
|
||||
|
||||
mockIsAuthenticated.mockReturnValue(true);
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
+217
@@ -0,0 +1,217 @@
|
||||
/**
|
||||
* extensionPointProps/extensionPointCallbacks 테스트
|
||||
*
|
||||
* engine-v1.28.0: props/callbacks 분리
|
||||
* - extensionPointProps: resolveObject()로 재귀 표현식 평가
|
||||
* - extensionPointCallbacks: 평가 없이 그대로 전달
|
||||
*/
|
||||
|
||||
import React from 'react';
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import { render, screen } from '@testing-library/react';
|
||||
import DynamicRenderer, { ComponentDefinition } from '../DynamicRenderer';
|
||||
import { ComponentRegistry } from '../ComponentRegistry';
|
||||
import { DataBindingEngine } from '../DataBindingEngine';
|
||||
import { TranslationEngine, TranslationContext } from '../TranslationEngine';
|
||||
import { ActionDispatcher } from '../ActionDispatcher';
|
||||
|
||||
const TestSpan: React.FC<{
|
||||
value?: any;
|
||||
items?: any;
|
||||
mapping?: any;
|
||||
callback?: any;
|
||||
'data-testid'?: string;
|
||||
children?: React.ReactNode;
|
||||
}> = ({ value, items, mapping, callback, 'data-testid': testId, children }) => (
|
||||
<span data-testid={testId || 'test-span'}>
|
||||
{value !== undefined ? String(value) : ''}
|
||||
{items !== undefined && <span data-testid="items">{JSON.stringify(items)}</span>}
|
||||
{mapping !== undefined && <span data-testid="mapping">{JSON.stringify(mapping)}</span>}
|
||||
{callback !== undefined && <span data-testid="callback">{typeof callback === 'object' ? JSON.stringify(callback) : String(callback)}</span>}
|
||||
{children}
|
||||
</span>
|
||||
);
|
||||
|
||||
describe('extensionPointProps/extensionPointCallbacks', () => {
|
||||
let registry: ComponentRegistry;
|
||||
let bindingEngine: DataBindingEngine;
|
||||
let translationEngine: TranslationEngine;
|
||||
let actionDispatcher: ActionDispatcher;
|
||||
let translationContext: TranslationContext;
|
||||
|
||||
beforeEach(() => {
|
||||
registry = ComponentRegistry.getInstance();
|
||||
(registry as any).registry = {
|
||||
Span: {
|
||||
component: TestSpan,
|
||||
metadata: { name: 'Span', type: 'basic' },
|
||||
},
|
||||
};
|
||||
|
||||
bindingEngine = new DataBindingEngine();
|
||||
translationEngine = new TranslationEngine();
|
||||
actionDispatcher = new ActionDispatcher({ navigate: vi.fn() });
|
||||
translationContext = { templateId: 'test-template', locale: 'ko' };
|
||||
});
|
||||
|
||||
describe('extensionPointProps (표현식 평가)', () => {
|
||||
it('단순 표현식 문자열이 평가되어야 한다', () => {
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-1',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', value: '{{extensionPointProps.productId}}' },
|
||||
extensionPointProps: { productId: '{{route.id}}' },
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{ route: { id: '42' } }}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
expect(screen.getByTestId('result').textContent).toBe('42');
|
||||
});
|
||||
|
||||
it('복합 표현식이 평가되어야 한다', () => {
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-2',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', value: '{{extensionPointProps.currency}}' },
|
||||
extensionPointProps: { currency: "{{_global.currency ?? 'KRW'}}" },
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{ _global: { currency: 'USD' } }}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
expect(screen.getByTestId('result').textContent).toBe('USD');
|
||||
});
|
||||
|
||||
it('정적 문자열은 그대로 전달되어야 한다', () => {
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-3',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', value: '{{extensionPointProps.shopName}}' },
|
||||
extensionPointProps: { shopName: 'My Shop' },
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{}}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
expect(screen.getByTestId('result').textContent).toBe('My Shop');
|
||||
});
|
||||
|
||||
it('배열은 그대로 전달되어야 한다', () => {
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-4',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', items: '{{extensionPointProps.fields}}' },
|
||||
extensionPointProps: { fields: ['zipcode', 'address'] },
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{}}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
expect(screen.getByTestId('items').textContent).toBe('["zipcode","address"]');
|
||||
});
|
||||
|
||||
it('객체 내부의 표현식도 재귀적으로 평가되어야 한다', () => {
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-5',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', mapping: '{{extensionPointProps.targetFields}}' },
|
||||
extensionPointProps: {
|
||||
targetFields: {
|
||||
zipcode: '{{_local.formPrefix}}.zipcode',
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{ _local: { formPrefix: 'shipping' } }}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
const mapping = JSON.parse(screen.getByTestId('mapping').textContent || '{}');
|
||||
expect(mapping.zipcode).toBe('shipping.zipcode');
|
||||
});
|
||||
});
|
||||
|
||||
describe('extensionPointCallbacks (평가 없이 전달)', () => {
|
||||
it('액션 객체가 평가 없이 그대로 전달되어야 한다', () => {
|
||||
const actionObj = {
|
||||
handler: 'setState',
|
||||
params: { target: 'local', 'form.zipcode': '{{$event.zipcode}}' },
|
||||
};
|
||||
|
||||
const componentDef: ComponentDefinition = {
|
||||
id: 'test-6',
|
||||
type: 'basic',
|
||||
name: 'Span',
|
||||
props: { 'data-testid': 'result', callback: '{{extensionPointCallbacks.onAddressSelect}}' },
|
||||
extensionPointCallbacks: { onAddressSelect: actionObj },
|
||||
};
|
||||
|
||||
render(
|
||||
<DynamicRenderer
|
||||
componentDef={componentDef}
|
||||
dataContext={{}}
|
||||
translationContext={translationContext}
|
||||
registry={registry}
|
||||
bindingEngine={bindingEngine}
|
||||
translationEngine={translationEngine}
|
||||
actionDispatcher={actionDispatcher}
|
||||
/>
|
||||
);
|
||||
|
||||
const result = JSON.parse(screen.getByTestId('callback').textContent || '{}');
|
||||
// $event 표현식이 평가되지 않고 원본 그대로 보존되어야 함
|
||||
expect(result.handler).toBe('setState');
|
||||
expect(result.params['form.zipcode']).toBe('{{$event.zipcode}}');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1200,5 +1200,33 @@ describe('TranslationEngine', () => {
|
||||
await engine.loadTranslations('template-1', 'ko');
|
||||
expect(global.fetch).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// @since engine-v1.38.1
|
||||
// 회귀 방지: reloadExtensions 병렬 실행 중 setCacheVersion 이 활성 translations 맵을
|
||||
// 비워서 같은 parallel 블록 내의 toast($t:...) 가 raw key 를 반환하던 경합 조건
|
||||
it('setCacheVersion 호출 후에도 이전 번역이 즉시 조회 가능해야 한다 (loadTranslations 완료 전)', async () => {
|
||||
const mockTranslations = {
|
||||
admin: { modules: { activate_success: '모듈 활성화 성공' } },
|
||||
};
|
||||
|
||||
// 1. 초기 번역 로드
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => mockTranslations,
|
||||
});
|
||||
await engine.loadTranslations('template-1', 'ko');
|
||||
|
||||
const context: TranslationContext = { templateId: 'template-1', locale: 'ko' };
|
||||
|
||||
// 2. 로드 직후 번역 조회 성공
|
||||
expect(engine.translate('admin.modules.activate_success', context)).toBe('모듈 활성화 성공');
|
||||
|
||||
// 3. 캐시 버전 변경 (reloadExtensions 내부에서 일어나는 동작)
|
||||
engine.setCacheVersion(1735000000);
|
||||
|
||||
// 4. loadTranslations 재호출 전에도 기존 번역은 유지되어야 함
|
||||
// → 병렬 toast 가 raw key 가 아닌 실제 번역을 받음
|
||||
expect(engine.translate('admin.modules.activate_success', context)).toBe('모듈 활성화 성공');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -278,6 +278,67 @@ describe('트러블슈팅 회귀 테스트 - 캐시 관련', () => {
|
||||
expect(uniqueIds.size).toBe(modalIds.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe('[사례 16] 확장 라이프사이클 직후 라우트/다국어 미반영 + 토스트 raw key 노출', () => {
|
||||
/**
|
||||
* 증상:
|
||||
* 1. 모듈 활성화 직후 새 라우트가 페이지 전체 새로고침 전까지 반영되지 않음
|
||||
* 2. 성공 토스트가 `admin.modules.activate_success` 원본 번역 키를 표시
|
||||
*
|
||||
* 근본 원인 3건:
|
||||
* (a) Router.loadRoutes 가 ?v=cacheVersion 을 부착하지 않음 — PublicTemplateController::getRoutes 가 v 기반 캐싱
|
||||
* (b) TranslationEngine.setCacheVersion 이 this.translations 를 clear — parallel toast 와 경합
|
||||
* (c) $t() 헬퍼가 context.$templateId 누락 시 빈 templateId 로 lookup 실패
|
||||
*
|
||||
* 전체 회귀 테스트는 다음 파일들에 분산:
|
||||
* - resources/js/core/routing/__tests__/Router.test.ts (cacheVersion 쿼리 부착)
|
||||
* - resources/js/core/template-engine/__tests__/TranslationEngine.test.ts (setCacheVersion 원자성)
|
||||
* - resources/js/core/template-engine/__tests__/DataBindingEngine.test.ts ($t fallback)
|
||||
* - resources/js/core/template-engine/__tests__/ActionDispatcher.reloadExtensions.test.ts
|
||||
*
|
||||
* @since engine-v1.38.0 / 1.38.1 / 1.38.2
|
||||
*/
|
||||
it('Router.loadRoutes 는 cacheVersion 전달 시 ?v= 쿼리를 부착해야 함 (사례 16-a)', () => {
|
||||
const buildUrl = (templateId: string, cacheVersion?: number) => {
|
||||
const versionQuery = cacheVersion !== undefined && cacheVersion > 0
|
||||
? `?v=${cacheVersion}`
|
||||
: '';
|
||||
return `/api/templates/${templateId}/routes.json${versionQuery}`;
|
||||
};
|
||||
expect(buildUrl('x', 1776225501)).toBe('/api/templates/x/routes.json?v=1776225501');
|
||||
expect(buildUrl('x', 0)).toBe('/api/templates/x/routes.json');
|
||||
expect(buildUrl('x', undefined)).toBe('/api/templates/x/routes.json');
|
||||
});
|
||||
|
||||
it('setCacheVersion 직후에도 활성 translations 가 유지되어야 함 (사례 16-b)', () => {
|
||||
const translations = new Map<string, any>();
|
||||
const ttlCache = new Map<string, any>();
|
||||
translations.set('x:ko', { admin: { modules: { activate_success: '성공' } } });
|
||||
ttlCache.set('x:ko', { admin: { modules: { activate_success: '성공' } } });
|
||||
|
||||
// setCacheVersion 새 동작: TTL 캐시만 clear, 활성 translations 유지
|
||||
ttlCache.clear();
|
||||
|
||||
expect(translations.get('x:ko')?.admin?.modules?.activate_success).toBe('성공');
|
||||
expect(ttlCache.has('x:ko')).toBe(false);
|
||||
});
|
||||
|
||||
it('$t() fallback — context.$templateId 누락 시 window.__templateApp.getConfig() 사용 (사례 16-c)', () => {
|
||||
const mockTemplateApp = {
|
||||
getConfig: () => ({ templateId: 'sirsoft-admin_basic', locale: 'ko' }),
|
||||
};
|
||||
const resolveTemplateId = (context: Record<string, any>, windowRef: any): string => {
|
||||
let templateId = context.$templateId;
|
||||
if (!templateId) {
|
||||
templateId = windowRef?.__templateApp?.getConfig?.()?.templateId;
|
||||
}
|
||||
return templateId || '';
|
||||
};
|
||||
expect(resolveTemplateId({}, { __templateApp: mockTemplateApp })).toBe('sirsoft-admin_basic');
|
||||
expect(resolveTemplateId({ $templateId: 'explicit' }, { __templateApp: mockTemplateApp })).toBe('explicit');
|
||||
expect(resolveTemplateId({}, {})).toBe('');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('트러블슈팅 회귀 테스트 - 바인딩 엔진 캐시', () => {
|
||||
|
||||
@@ -1024,4 +1024,102 @@ describe('트러블슈팅 회귀 테스트 - 렌더링 구조', () => {
|
||||
expect(shouldTranslate).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* [사례 22-1] FileUploader 갤러리 이미지 blob URL stale closure
|
||||
*
|
||||
* 증상: 갤러리(Lightbox) 열리지만 이미지가 표시되지 않음 (blob URL 에러)
|
||||
* 원인: authenticatedImageUrls useEffect cleanup에서 blob URL revoke 후
|
||||
* Map 미초기화 → stale closure의 has() 체크가 재로딩 건너뜀
|
||||
* 해결: ref 기반 캐시 + 언마운트 전용 cleanup 분리
|
||||
*/
|
||||
describe('[사례 22-1] FileUploader 갤러리 blob URL stale closure', () => {
|
||||
it('ref 기반 캐시는 existingFiles 변경 후에도 has() 체크가 최신 상태를 참조한다', () => {
|
||||
// state 기반 (버그): 클로저가 이전 렌더의 스냅샷 캡처
|
||||
let stateMap = new Map<number, string>();
|
||||
const closureCapturedMap = stateMap; // effect 생성 시점의 스냅샷
|
||||
|
||||
// 비동기 state 업데이트 시뮬레이션
|
||||
stateMap = new Map(stateMap);
|
||||
stateMap.set(1, 'blob:url-1');
|
||||
stateMap.set(2, 'blob:url-2');
|
||||
|
||||
// state 기반: 클로저의 has()는 빈 Map 참조 → 업데이트 못 봄
|
||||
expect(closureCapturedMap.has(1)).toBe(false); // stale!
|
||||
|
||||
// ref 기반 (수정): 항상 최신 참조
|
||||
const refMap = { current: new Map<number, string>() };
|
||||
refMap.current.set(1, 'blob:url-1');
|
||||
refMap.current.set(2, 'blob:url-2');
|
||||
|
||||
// ref 기반: 항상 최신 상태 참조
|
||||
expect(refMap.current.has(1)).toBe(true);
|
||||
expect(refMap.current.has(2)).toBe(true);
|
||||
});
|
||||
|
||||
it('cleanup에서 revoke 후 Map을 clear하지 않으면 재로딩이 건너뛰어진다', () => {
|
||||
const urlCache = new Map<number, string>();
|
||||
urlCache.set(1, 'blob:url-1');
|
||||
urlCache.set(2, 'blob:url-2');
|
||||
|
||||
// cleanup: revoke만 하고 Map은 clear 안 함 (버그 패턴)
|
||||
const revokedUrls: string[] = [];
|
||||
urlCache.forEach((url) => revokedUrls.push(url));
|
||||
// URL.revokeObjectURL(url) 시뮬레이션 — URL은 무효화되지만 Map에 남아있음
|
||||
|
||||
// 새 effect에서 has() 체크
|
||||
const shouldLoad1 = !urlCache.has(1); // false! Map에 남아있으므로
|
||||
const shouldLoad2 = !urlCache.has(2); // false!
|
||||
|
||||
expect(shouldLoad1).toBe(false); // 재로딩 건너뜀 → 버그!
|
||||
expect(shouldLoad2).toBe(false);
|
||||
expect(revokedUrls).toEqual(['blob:url-1', 'blob:url-2']);
|
||||
|
||||
// 수정: ref 기반에서는 revoke된 파일의 URL을 삭제하고 새로 로드
|
||||
const refCache = { current: new Map<number, string>() };
|
||||
refCache.current.set(1, 'blob:url-1');
|
||||
refCache.current.set(2, 'blob:url-2');
|
||||
|
||||
// existingFiles에서 제거된 파일만 정리 (현재 파일 ID 집합)
|
||||
const currentIds = new Set([1, 2]);
|
||||
for (const [id] of refCache.current) {
|
||||
if (!currentIds.has(id)) {
|
||||
refCache.current.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
// 기존 파일은 캐시에 유지 → 재로딩 불필요
|
||||
expect(refCache.current.has(1)).toBe(true);
|
||||
expect(refCache.current.has(2)).toBe(true);
|
||||
});
|
||||
|
||||
it('비동기 로딩 중 cancelled 플래그로 stale 업데이트를 방지한다', async () => {
|
||||
let cancelled = false;
|
||||
const results: number[] = [];
|
||||
|
||||
const loadAsync = async () => {
|
||||
for (const id of [1, 2, 3]) {
|
||||
if (cancelled) break;
|
||||
// 비동기 작업 시뮬레이션
|
||||
await new Promise((r) => setTimeout(r, 1));
|
||||
if (!cancelled) {
|
||||
results.push(id);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const promise = loadAsync();
|
||||
|
||||
// 2번째 항목 로드 중 취소
|
||||
await new Promise((r) => setTimeout(r, 3));
|
||||
cancelled = true;
|
||||
|
||||
await promise;
|
||||
|
||||
// 취소 후에는 더 이상 추가되지 않음
|
||||
expect(results.length).toBeLessThanOrEqual(3);
|
||||
// cancelled 플래그가 동작함을 확인
|
||||
expect(cancelled).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -15,6 +15,8 @@ interface SortableItemWrapperProps {
|
||||
id: string | number;
|
||||
/** 드래그 핸들 CSS 선택자 (예: "[data-drag-handle]") */
|
||||
handle?: string;
|
||||
/** 래퍼 HTML 요소 (기본: "div", Table 내부에서는 "tr" 사용) @since engine-v1.18.0 */
|
||||
as?: React.ElementType;
|
||||
/** 자식 요소 */
|
||||
children: React.ReactNode;
|
||||
}
|
||||
@@ -26,11 +28,15 @@ interface SortableItemWrapperProps {
|
||||
* SortableProvider를 통해 listeners를 하위 컴포넌트에 전달합니다.
|
||||
* DynamicRenderer가 data-drag-handle 속성을 감지하여 자동으로 listeners를 적용합니다.
|
||||
*
|
||||
* `as` prop으로 래퍼 요소를 지정할 수 있습니다 (예: Table 내부에서 "tr" 사용).
|
||||
*
|
||||
* @since engine-v1.14.0
|
||||
* @since engine-v1.18.0 `as` prop 추가
|
||||
*/
|
||||
export const SortableItemWrapper: React.FC<SortableItemWrapperProps> = ({
|
||||
id,
|
||||
handle,
|
||||
as: WrapperElement = 'div',
|
||||
children,
|
||||
}) => {
|
||||
const {
|
||||
@@ -51,7 +57,7 @@ export const SortableItemWrapper: React.FC<SortableItemWrapperProps> = ({
|
||||
|
||||
|
||||
return (
|
||||
<div
|
||||
<WrapperElement
|
||||
ref={setNodeRef}
|
||||
style={style}
|
||||
{...attributes}
|
||||
@@ -63,7 +69,7 @@ export const SortableItemWrapper: React.FC<SortableItemWrapperProps> = ({
|
||||
<SortableProvider value={{ listeners, handle, isDragging }}>
|
||||
{children}
|
||||
</SortableProvider>
|
||||
</div>
|
||||
</WrapperElement>
|
||||
);
|
||||
};
|
||||
|
||||
|
||||
@@ -224,13 +224,34 @@ class WebSocketManager {
|
||||
/**
|
||||
* 구독을 해제합니다.
|
||||
*
|
||||
* @param subscriptionKey 구독 키
|
||||
* Map 엔트리 제거 + Echo 채널의 listener 명시 해제.
|
||||
* Echo는 동일 채널을 재사용하므로 stopListening() 누락 시
|
||||
* 재subscribe 시 listener가 중복 누적되어 콜백이 여러 번 실행됩니다.
|
||||
*
|
||||
* @param subscriptionKey 구독 키 (형식: "channel:event")
|
||||
*/
|
||||
unsubscribe(subscriptionKey: string): void {
|
||||
if (this.subscriptions.has(subscriptionKey)) {
|
||||
this.subscriptions.delete(subscriptionKey);
|
||||
logger.log(`[WebSocketManager] 구독 해제: ${subscriptionKey}`);
|
||||
const channelInstance = this.subscriptions.get(subscriptionKey);
|
||||
if (!channelInstance) {
|
||||
return;
|
||||
}
|
||||
|
||||
// subscriptionKey 형식: "channelName:eventName"
|
||||
// channelName이 ':'를 포함할 수 있으므로 마지막 ':' 기준 분리
|
||||
const lastColon = subscriptionKey.lastIndexOf(':');
|
||||
const eventName = lastColon >= 0 ? subscriptionKey.substring(lastColon + 1) : '';
|
||||
|
||||
if (eventName) {
|
||||
try {
|
||||
// Reverb 이벤트는 '.'으로 시작해야 함 (subscribe와 동일)
|
||||
channelInstance.stopListening(`.${eventName}`);
|
||||
} catch (e) {
|
||||
logger.warn(`[WebSocketManager] stopListening 실패: ${subscriptionKey}`, e);
|
||||
}
|
||||
}
|
||||
|
||||
this.subscriptions.delete(subscriptionKey);
|
||||
logger.log(`[WebSocketManager] 구독 해제: ${subscriptionKey}`);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -67,9 +67,9 @@
|
||||
debug: {{ config('app.debug') ? 'true' : 'false' }}@if(config('broadcasting.connections.reverb.key')),
|
||||
websocket: {
|
||||
appKey: '{{ config('broadcasting.connections.reverb.key') }}',
|
||||
host: '{{ config('broadcasting.connections.reverb.options.host', 'localhost') }}',
|
||||
port: {{ config('broadcasting.connections.reverb.options.port', 80) }},
|
||||
scheme: '{{ config('broadcasting.connections.reverb.options.scheme', 'https') }}'
|
||||
host: '{{ config('g7.websocket.client.host', config('broadcasting.connections.reverb.options.host', 'localhost')) }}',
|
||||
port: {{ config('g7.websocket.client.port', config('broadcasting.connections.reverb.options.port', 80)) }},
|
||||
scheme: '{{ config('g7.websocket.client.scheme', config('broadcasting.connections.reverb.options.scheme', 'https')) }}'
|
||||
}@endif
|
||||
});
|
||||
} else {
|
||||
|
||||
@@ -71,9 +71,9 @@
|
||||
debug: {{ config('app.debug') ? 'true' : 'false' }}@if(config('broadcasting.connections.reverb.key')),
|
||||
websocket: {
|
||||
appKey: '{{ config('broadcasting.connections.reverb.key') }}',
|
||||
host: '{{ config('broadcasting.connections.reverb.options.host', 'localhost') }}',
|
||||
port: {{ config('broadcasting.connections.reverb.options.port', 80) }},
|
||||
scheme: '{{ config('broadcasting.connections.reverb.options.scheme', 'https') }}'
|
||||
host: '{{ config('g7.websocket.client.host', config('broadcasting.connections.reverb.options.host', 'localhost')) }}',
|
||||
port: {{ config('g7.websocket.client.port', config('broadcasting.connections.reverb.options.port', 80)) }},
|
||||
scheme: '{{ config('g7.websocket.client.scheme', config('broadcasting.connections.reverb.options.scheme', 'https')) }}'
|
||||
}@endif
|
||||
});
|
||||
} else {
|
||||
|
||||
Reference in new issue
Block a user