Skip to content

Commit ce602fc

Browse files
caohuilincaohuilin
committed
feat: op code
1 parent f03555d commit ce602fc

File tree

3 files changed

+305
-245
lines changed

3 files changed

+305
-245
lines changed

‎packages/runtime/plugin-i18n/src/runtime/i18n/backend/index.ts‎

Lines changed: 145 additions & 90 deletions
Original file line numberDiff line numberDiff line change
@@ -9,93 +9,134 @@ import {
99
convertBackendOptions,
1010
} from './defaults';
1111

12-
export const mergeBackendOptions = (
12+
function hasSdkFunction(
1313
backend?: BaseBackendOptions,
1414
userInitOptions?: I18nInitOptions,
15-
) => {
16-
const hasSdkFunction =
15+
): boolean {
16+
return (
1717
typeof userInitOptions?.backend?.sdk === 'function' ||
18-
(backend?.enabled && backend?.sdk && typeof backend.sdk === 'function');
19-
// Check if user explicitly configured loadPath (non-empty string)
20-
// If backend.enabled is true and user didn't explicitly configure loadPath,
21-
// we will use default loadPath, so consider it as having loadPath
18+
(!!backend?.enabled && !!backend?.sdk && typeof backend.sdk === 'function')
19+
);
20+
}
21+
22+
/**
23+
* Checks if loadPath is configured.
24+
* If backend.enabled is true and user didn't explicitly configure loadPath,
25+
* we will use default loadPath, so consider it as having loadPath.
26+
*/
27+
function hasLoadPath(
28+
backend?: BaseBackendOptions,
29+
userInitOptions?: I18nInitOptions,
30+
): { hasPath: boolean; isExplicit: boolean } {
2231
const userLoadPath = userInitOptions?.backend?.loadPath ?? backend?.loadPath;
23-
const hasExplicitLoadPath = !!userLoadPath && userLoadPath !== '';
24-
const hasLoadPath =
25-
hasExplicitLoadPath || (backend?.enabled && userLoadPath === undefined);
26-
27-
// If both loadPath and sdk are provided, return chained backend config
28-
if (hasLoadPath && hasSdkFunction) {
29-
const merged = baseMergeBackendOptions(
30-
DEFAULT_I18NEXT_BACKEND_OPTIONS,
31-
backend as BackendOptions,
32-
userInitOptions?.backend,
33-
);
34-
// If user didn't explicitly configure loadPath but backend.enabled is true,
35-
// ensure default loadPath is used
36-
if (backend?.enabled && !hasExplicitLoadPath && !merged.loadPath) {
37-
merged.loadPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
38-
merged.addPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
39-
}
40-
const mergedOptions = convertBackendOptions(merged);
41-
42-
// Ensure loadPath and sdk are properly set
43-
const finalLoadPath =
44-
mergedOptions?.loadPath ||
45-
userInitOptions?.backend?.loadPath ||
46-
(backend?.enabled ? DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath : undefined);
47-
const finalSdk =
48-
mergedOptions?.sdk ||
49-
userInitOptions?.backend?.sdk ||
50-
(backend?.sdk && typeof backend.sdk === 'function'
51-
? backend.sdk
52-
: undefined);
53-
54-
// Return chained backend configuration
55-
// The actual backend classes will be set in middleware based on environment
56-
// cacheHitMode defaults to 'refreshAndUpdateStore' to allow FS/HTTP resources
57-
// to display first, then SDK resources will update them asynchronously
58-
const chainedBackendOptions = [
59-
{
60-
loadPath: finalLoadPath,
61-
addPath:
62-
mergedOptions?.addPath || DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath,
63-
},
64-
{
65-
sdk: finalSdk,
66-
},
67-
];
68-
69-
const result: ChainedBackendConfig & BaseBackendOptions = {
70-
...mergedOptions,
32+
const isExplicit: boolean = !!userLoadPath && userLoadPath !== '';
33+
const hasPath =
34+
isExplicit || (!!backend?.enabled && userLoadPath === undefined);
35+
36+
return { hasPath, isExplicit };
37+
}
38+
39+
function ensureDefaultLoadPath(
40+
merged: BackendOptions,
41+
backend?: BaseBackendOptions,
42+
isExplicitLoadPath = false,
43+
): void {
44+
if (backend?.enabled && !isExplicitLoadPath && !merged.loadPath) {
45+
merged.loadPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
46+
merged.addPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
47+
}
48+
}
49+
50+
function getFinalLoadPath(
51+
mergedOptions?: BackendOptions,
52+
backend?: BaseBackendOptions,
53+
userInitOptions?: I18nInitOptions,
54+
): string | undefined {
55+
return (
56+
mergedOptions?.loadPath ||
57+
userInitOptions?.backend?.loadPath ||
58+
(backend?.enabled ? DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath : undefined)
59+
);
60+
}
61+
62+
function getFinalSdk(
63+
mergedOptions?: BackendOptions,
64+
backend?: BaseBackendOptions,
65+
userInitOptions?: I18nInitOptions,
66+
): any {
67+
return (
68+
mergedOptions?.sdk ||
69+
userInitOptions?.backend?.sdk ||
70+
(backend?.sdk && typeof backend.sdk === 'function'
71+
? backend.sdk
72+
: undefined)
73+
);
74+
}
75+
76+
function buildChainedBackendConfig(
77+
backend?: BaseBackendOptions,
78+
userInitOptions?: I18nInitOptions,
79+
): ChainedBackendConfig & BaseBackendOptions {
80+
const merged = baseMergeBackendOptions(
81+
DEFAULT_I18NEXT_BACKEND_OPTIONS,
82+
backend as BackendOptions,
83+
userInitOptions?.backend,
84+
);
85+
86+
const { isExplicit } = hasLoadPath(backend, userInitOptions);
87+
ensureDefaultLoadPath(merged, backend, isExplicit);
88+
89+
const mergedOptions = convertBackendOptions(merged);
90+
const finalLoadPath = getFinalLoadPath(
91+
mergedOptions,
92+
backend,
93+
userInitOptions,
94+
);
95+
const finalSdk = getFinalSdk(mergedOptions, backend, userInitOptions);
96+
97+
const chainedBackendOptions = [
98+
{
7199
loadPath: finalLoadPath,
100+
addPath:
101+
mergedOptions?.addPath || DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath,
102+
},
103+
{
72104
sdk: finalSdk,
73-
cacheHitMode:
74-
mergedOptions?.cacheHitMode ||
75-
(backend as BackendOptions)?.cacheHitMode ||
76-
userInitOptions?.backend?.cacheHitMode ||
77-
'refreshAndUpdateStore',
78-
_useChainedBackend: true,
79-
_chainedBackendConfig: {
80-
// These will be populated in middleware
81-
backendOptions: chainedBackendOptions,
82-
},
83-
};
84-
85-
return result;
86-
}
105+
},
106+
];
87107

88-
// If only SDK is provided, use SDK backend
89-
if (hasSdkFunction) {
90-
const merged = baseMergeBackendOptions(
91-
{} as BackendOptions,
92-
backend as BackendOptions,
93-
userInitOptions?.backend,
94-
);
95-
return convertBackendOptions(merged);
96-
}
108+
return {
109+
...mergedOptions,
110+
loadPath: finalLoadPath,
111+
sdk: finalSdk,
112+
cacheHitMode:
113+
mergedOptions?.cacheHitMode ||
114+
(backend as BackendOptions)?.cacheHitMode ||
115+
userInitOptions?.backend?.cacheHitMode ||
116+
'refreshAndUpdateStore',
117+
_useChainedBackend: true,
118+
_chainedBackendConfig: {
119+
backendOptions: chainedBackendOptions,
120+
},
121+
};
122+
}
123+
124+
function buildSdkOnlyBackendConfig(
125+
backend?: BaseBackendOptions,
126+
userInitOptions?: I18nInitOptions,
127+
): BackendOptions {
128+
const merged = baseMergeBackendOptions(
129+
{} as BackendOptions,
130+
backend as BackendOptions,
131+
userInitOptions?.backend,
132+
);
133+
return convertBackendOptions(merged) || ({} as BackendOptions);
134+
}
97135

98-
// Otherwise, use HTTP/FS backend
136+
function buildHttpFsBackendConfig(
137+
backend?: BaseBackendOptions,
138+
userInitOptions?: I18nInitOptions,
139+
): BackendOptions {
99140
const mergedBackend = backend?.enabled
100141
? baseMergeBackendOptions(
101142
DEFAULT_I18NEXT_BACKEND_OPTIONS,
@@ -104,17 +145,31 @@ export const mergeBackendOptions = (
104145
)
105146
: userInitOptions?.backend;
106147

107-
// If user didn't explicitly configure loadPath but backend.enabled is true,
108-
// ensure default loadPath is used
109-
if (
110-
mergedBackend &&
111-
backend?.enabled &&
112-
!hasExplicitLoadPath &&
113-
!mergedBackend.loadPath
114-
) {
115-
mergedBackend.loadPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
116-
mergedBackend.addPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
148+
if (mergedBackend) {
149+
const { isExplicit } = hasLoadPath(backend, userInitOptions);
150+
ensureDefaultLoadPath(mergedBackend, backend, isExplicit);
151+
}
152+
153+
return (
154+
convertBackendOptions(mergedBackend as BackendOptions) ||
155+
({} as BackendOptions)
156+
);
157+
}
158+
159+
export const mergeBackendOptions = (
160+
backend?: BaseBackendOptions,
161+
userInitOptions?: I18nInitOptions,
162+
) => {
163+
const sdkFunction = hasSdkFunction(backend, userInitOptions);
164+
const { hasPath } = hasLoadPath(backend, userInitOptions);
165+
166+
if (hasPath && sdkFunction) {
167+
return buildChainedBackendConfig(backend, userInitOptions);
168+
}
169+
170+
if (sdkFunction) {
171+
return buildSdkOnlyBackendConfig(backend, userInitOptions);
117172
}
118173

119-
return convertBackendOptions(mergedBackend as BackendOptions);
174+
return buildHttpFsBackendConfig(backend, userInitOptions);
120175
};

0 commit comments

Comments
 (0)