@chuckcchen/vite-plugin 1.0.11 → 1.0.13
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/factory/detectors.d.ts +23 -0
- package/dist/factory/detectors.d.ts.map +1 -0
- package/dist/factory/detectors.js +60 -0
- package/dist/factory/detectors.js.map +1 -0
- package/dist/factory/hooks.d.ts +84 -0
- package/dist/factory/hooks.d.ts.map +1 -0
- package/dist/factory/hooks.js +227 -0
- package/dist/factory/hooks.js.map +1 -0
- package/dist/factory/index.d.ts +68 -0
- package/dist/factory/index.d.ts.map +1 -0
- package/dist/factory/index.js +92 -0
- package/dist/factory/index.js.map +1 -0
- package/dist/factory/presets.d.ts +105 -0
- package/dist/factory/presets.d.ts.map +1 -0
- package/dist/factory/presets.js +172 -0
- package/dist/factory/presets.js.map +1 -0
- package/dist/factory.d.ts +60 -8
- package/dist/factory.d.ts.map +1 -1
- package/dist/factory.js +159 -46
- package/dist/factory.js.map +1 -1
- package/dist/index.d.ts +5 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +7 -1
- package/dist/index.js.map +1 -1
- package/dist/route-parser.d.ts +26 -4
- package/dist/route-parser.d.ts.map +1 -1
- package/dist/route-parser.js +12 -10
- package/dist/route-parser.js.map +1 -1
- package/dist/utils.d.ts +9 -1
- package/dist/utils.d.ts.map +1 -1
- package/dist/utils.js +35 -1
- package/dist/utils.js.map +1 -1
- package/dist/vite-config-parser.d.ts +203 -0
- package/dist/vite-config-parser.d.ts.map +1 -0
- package/dist/vite-config-parser.js +465 -0
- package/dist/vite-config-parser.js.map +1 -0
- package/package.json +1 -1
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Server Wrapper Presets
|
|
3
|
+
*
|
|
4
|
+
* Built-in presets and utilities for extending presets
|
|
5
|
+
*/
|
|
6
|
+
/**
|
|
7
|
+
* Server wrapper preset configuration
|
|
8
|
+
*/
|
|
9
|
+
export interface ServerWrapperPreset {
|
|
10
|
+
imports?: string;
|
|
11
|
+
handlerSetup: string;
|
|
12
|
+
handlerCall: string;
|
|
13
|
+
requiresHtmlTemplate?: boolean;
|
|
14
|
+
}
|
|
15
|
+
/**
|
|
16
|
+
* Built-in server wrapper presets (generic, framework-agnostic)
|
|
17
|
+
*
|
|
18
|
+
* Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
|
|
19
|
+
* which are automatically provided by generateServerWrapperCode()
|
|
20
|
+
*
|
|
21
|
+
* Framework-specific presets should be defined in their respective adapter packages.
|
|
22
|
+
*/
|
|
23
|
+
export declare const SERVER_WRAPPER_PRESETS: {
|
|
24
|
+
/**
|
|
25
|
+
* Web Handler - Request/Response pattern
|
|
26
|
+
*
|
|
27
|
+
* Supports multiple export patterns:
|
|
28
|
+
* - default export function
|
|
29
|
+
* - named `handler` export
|
|
30
|
+
* - named `fetch` export
|
|
31
|
+
* - `app.fetch` pattern (Hono style)
|
|
32
|
+
*/
|
|
33
|
+
readonly webHandler: {
|
|
34
|
+
readonly handlerSetup: string;
|
|
35
|
+
readonly handlerCall: "handler(webRequest, ...args)";
|
|
36
|
+
};
|
|
37
|
+
/**
|
|
38
|
+
* HTML Render - render function returning {head, html}
|
|
39
|
+
*
|
|
40
|
+
* Standard Vite SSR pattern where render(url) returns HTML fragments
|
|
41
|
+
* that are injected into the HTML template.
|
|
42
|
+
*/
|
|
43
|
+
readonly htmlRender: {
|
|
44
|
+
readonly requiresHtmlTemplate: true;
|
|
45
|
+
readonly handlerSetup: string;
|
|
46
|
+
readonly handlerCall: "handleSSRRequest(webRequest)";
|
|
47
|
+
};
|
|
48
|
+
};
|
|
49
|
+
/**
|
|
50
|
+
* Result of extending server wrapper presets
|
|
51
|
+
*/
|
|
52
|
+
export interface ExtendedPresetsResult<TCustom extends Record<string, ServerWrapperPreset>> {
|
|
53
|
+
/** Extended presets object (core + custom) */
|
|
54
|
+
presets: typeof SERVER_WRAPPER_PRESETS & TCustom;
|
|
55
|
+
/** Type-safe preset resolver function */
|
|
56
|
+
resolvePreset: (preset: keyof (typeof SERVER_WRAPPER_PRESETS & TCustom) | ServerWrapperPreset) => ServerWrapperPreset;
|
|
57
|
+
/** Get all available preset names */
|
|
58
|
+
getPresetNames: () => (keyof (typeof SERVER_WRAPPER_PRESETS & TCustom))[];
|
|
59
|
+
}
|
|
60
|
+
/**
|
|
61
|
+
* Create a server wrapper preset
|
|
62
|
+
*
|
|
63
|
+
* Helper function to create a properly typed preset with validation and normalization.
|
|
64
|
+
* Automatically trims handlerSetup and validates required fields.
|
|
65
|
+
*
|
|
66
|
+
* @example
|
|
67
|
+
* ```ts
|
|
68
|
+
* const myPreset = createServerWrapperPreset({
|
|
69
|
+
* imports: `import { handler } from 'my-framework';`,
|
|
70
|
+
* handlerSetup: `const requestHandler = handler(serverExports);`,
|
|
71
|
+
* handlerCall: "requestHandler(webRequest)",
|
|
72
|
+
* });
|
|
73
|
+
* ```
|
|
74
|
+
*/
|
|
75
|
+
export declare function createServerWrapperPreset(config: ServerWrapperPreset): ServerWrapperPreset;
|
|
76
|
+
/**
|
|
77
|
+
* Extend core server wrapper presets with custom presets
|
|
78
|
+
*
|
|
79
|
+
* This utility provides a standardized way for adapters to:
|
|
80
|
+
* 1. Add framework-specific presets while keeping core presets
|
|
81
|
+
* 2. Get a type-safe resolver function
|
|
82
|
+
* 3. Export extended presets for external use
|
|
83
|
+
*
|
|
84
|
+
* Custom presets are automatically validated and normalized using createServerWrapperPreset().
|
|
85
|
+
*
|
|
86
|
+
* @example
|
|
87
|
+
* ```ts
|
|
88
|
+
* // In vite-adapter - can pass raw config, will be validated automatically
|
|
89
|
+
* const { presets, resolvePreset } = extendServerWrapperPresets({
|
|
90
|
+
* vike: {
|
|
91
|
+
* imports: `import { renderPage } from 'vike/server';`,
|
|
92
|
+
* handlerSetup: `...`,
|
|
93
|
+
* handlerCall: "handleVikeRequest(webRequest)",
|
|
94
|
+
* },
|
|
95
|
+
* });
|
|
96
|
+
*
|
|
97
|
+
* export const SERVER_WRAPPER_PRESETS = presets;
|
|
98
|
+
* export type ServerWrapperPresetName = keyof typeof presets;
|
|
99
|
+
*
|
|
100
|
+
* // Use in adapter
|
|
101
|
+
* const resolved = resolvePreset(options.serverWrapper || "htmlRender");
|
|
102
|
+
* ```
|
|
103
|
+
*/
|
|
104
|
+
export declare function extendServerWrapperPresets<TCustom extends Record<string, ServerWrapperPreset>>(customPresets: TCustom): ExtendedPresetsResult<TCustom>;
|
|
105
|
+
//# sourceMappingURL=presets.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/factory/presets.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;IACjC;;;;;;;;OAQG;;;;;IAoBH;;;;;OAKG;;;;;;CAoCK,CAAC;AAMX;;GAEG;AACH,MAAM,WAAW,qBAAqB,CACpC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAEnD,8CAA8C;IAC9C,OAAO,EAAE,OAAO,sBAAsB,GAAG,OAAO,CAAC;IACjD,yCAAyC;IACzC,aAAa,EAAE,CACb,MAAM,EAAE,MAAM,CAAC,OAAO,sBAAsB,GAAG,OAAO,CAAC,GAAG,mBAAmB,KAC1E,mBAAmB,CAAC;IACzB,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,sBAAsB,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;CAC3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAarB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACnD,aAAa,EAAE,OAAO,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAwCxD"}
|
|
@@ -0,0 +1,172 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Server Wrapper Presets
|
|
3
|
+
*
|
|
4
|
+
* Built-in presets and utilities for extending presets
|
|
5
|
+
*/
|
|
6
|
+
/**
|
|
7
|
+
* Built-in server wrapper presets (generic, framework-agnostic)
|
|
8
|
+
*
|
|
9
|
+
* Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
|
|
10
|
+
* which are automatically provided by generateServerWrapperCode()
|
|
11
|
+
*
|
|
12
|
+
* Framework-specific presets should be defined in their respective adapter packages.
|
|
13
|
+
*/
|
|
14
|
+
export const SERVER_WRAPPER_PRESETS = {
|
|
15
|
+
/**
|
|
16
|
+
* Web Handler - Request/Response pattern
|
|
17
|
+
*
|
|
18
|
+
* Supports multiple export patterns:
|
|
19
|
+
* - default export function
|
|
20
|
+
* - named `handler` export
|
|
21
|
+
* - named `fetch` export
|
|
22
|
+
* - `app.fetch` pattern (Hono style)
|
|
23
|
+
*/
|
|
24
|
+
webHandler: {
|
|
25
|
+
handlerSetup: `
|
|
26
|
+
const getHandler = () => {
|
|
27
|
+
// 1. default export (highest priority)
|
|
28
|
+
if (typeof defaultExport === 'function') return defaultExport;
|
|
29
|
+
// 2. named handler export
|
|
30
|
+
if (typeof serverExports.handler === 'function') return serverExports.handler;
|
|
31
|
+
// 3. named fetch export
|
|
32
|
+
if (typeof serverExports.fetch === 'function') return serverExports.fetch;
|
|
33
|
+
// 4. app.fetch pattern (Hono style)
|
|
34
|
+
if (typeof serverExports.app === 'object' && typeof serverExports.app.fetch === 'function') {
|
|
35
|
+
return serverExports.app.fetch.bind(serverExports.app);
|
|
36
|
+
}
|
|
37
|
+
throw new Error('No handler found. Expected: default export, handler, fetch, or app.fetch');
|
|
38
|
+
};
|
|
39
|
+
const handler = getHandler();`.trim(),
|
|
40
|
+
handlerCall: "handler(webRequest, ...args)",
|
|
41
|
+
},
|
|
42
|
+
/**
|
|
43
|
+
* HTML Render - render function returning {head, html}
|
|
44
|
+
*
|
|
45
|
+
* Standard Vite SSR pattern where render(url) returns HTML fragments
|
|
46
|
+
* that are injected into the HTML template.
|
|
47
|
+
*/
|
|
48
|
+
htmlRender: {
|
|
49
|
+
requiresHtmlTemplate: true,
|
|
50
|
+
handlerSetup: `
|
|
51
|
+
const renderFn = typeof serverExports.render === 'function'
|
|
52
|
+
? serverExports.render
|
|
53
|
+
: (typeof defaultExport === 'function' ? defaultExport : null);
|
|
54
|
+
|
|
55
|
+
if (!renderFn) {
|
|
56
|
+
throw new Error('No render function found in server build. Expected export: render(url)');
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
async function handleSSRRequest(request) {
|
|
60
|
+
const url = new URL(request.url);
|
|
61
|
+
const pathname = url.pathname;
|
|
62
|
+
|
|
63
|
+
try {
|
|
64
|
+
const rendered = await renderFn(pathname);
|
|
65
|
+
let html = __HTML_TEMPLATE__
|
|
66
|
+
.replace('<!--app-head-->', rendered.head ?? '')
|
|
67
|
+
.replace('<!--app-html-->', rendered.html ?? '');
|
|
68
|
+
|
|
69
|
+
return new Response(html, {
|
|
70
|
+
status: 200,
|
|
71
|
+
headers: { 'Content-Type': 'text/html; charset=utf-8' }
|
|
72
|
+
});
|
|
73
|
+
} catch (error) {
|
|
74
|
+
console.error('SSR render error:', error);
|
|
75
|
+
return new Response('Internal Server Error: ' + error.message, {
|
|
76
|
+
status: 500,
|
|
77
|
+
headers: { 'Content-Type': 'text/plain' }
|
|
78
|
+
});
|
|
79
|
+
}
|
|
80
|
+
}`.trim(),
|
|
81
|
+
handlerCall: "handleSSRRequest(webRequest)",
|
|
82
|
+
},
|
|
83
|
+
};
|
|
84
|
+
/**
|
|
85
|
+
* Create a server wrapper preset
|
|
86
|
+
*
|
|
87
|
+
* Helper function to create a properly typed preset with validation and normalization.
|
|
88
|
+
* Automatically trims handlerSetup and validates required fields.
|
|
89
|
+
*
|
|
90
|
+
* @example
|
|
91
|
+
* ```ts
|
|
92
|
+
* const myPreset = createServerWrapperPreset({
|
|
93
|
+
* imports: `import { handler } from 'my-framework';`,
|
|
94
|
+
* handlerSetup: `const requestHandler = handler(serverExports);`,
|
|
95
|
+
* handlerCall: "requestHandler(webRequest)",
|
|
96
|
+
* });
|
|
97
|
+
* ```
|
|
98
|
+
*/
|
|
99
|
+
export function createServerWrapperPreset(config) {
|
|
100
|
+
if (!config.handlerSetup) {
|
|
101
|
+
throw new Error("Server wrapper preset must have handlerSetup");
|
|
102
|
+
}
|
|
103
|
+
if (!config.handlerCall) {
|
|
104
|
+
throw new Error("Server wrapper preset must have handlerCall");
|
|
105
|
+
}
|
|
106
|
+
return {
|
|
107
|
+
imports: config.imports,
|
|
108
|
+
handlerSetup: config.handlerSetup.trim(),
|
|
109
|
+
handlerCall: config.handlerCall,
|
|
110
|
+
requiresHtmlTemplate: config.requiresHtmlTemplate,
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
/**
|
|
114
|
+
* Extend core server wrapper presets with custom presets
|
|
115
|
+
*
|
|
116
|
+
* This utility provides a standardized way for adapters to:
|
|
117
|
+
* 1. Add framework-specific presets while keeping core presets
|
|
118
|
+
* 2. Get a type-safe resolver function
|
|
119
|
+
* 3. Export extended presets for external use
|
|
120
|
+
*
|
|
121
|
+
* Custom presets are automatically validated and normalized using createServerWrapperPreset().
|
|
122
|
+
*
|
|
123
|
+
* @example
|
|
124
|
+
* ```ts
|
|
125
|
+
* // In vite-adapter - can pass raw config, will be validated automatically
|
|
126
|
+
* const { presets, resolvePreset } = extendServerWrapperPresets({
|
|
127
|
+
* vike: {
|
|
128
|
+
* imports: `import { renderPage } from 'vike/server';`,
|
|
129
|
+
* handlerSetup: `...`,
|
|
130
|
+
* handlerCall: "handleVikeRequest(webRequest)",
|
|
131
|
+
* },
|
|
132
|
+
* });
|
|
133
|
+
*
|
|
134
|
+
* export const SERVER_WRAPPER_PRESETS = presets;
|
|
135
|
+
* export type ServerWrapperPresetName = keyof typeof presets;
|
|
136
|
+
*
|
|
137
|
+
* // Use in adapter
|
|
138
|
+
* const resolved = resolvePreset(options.serverWrapper || "htmlRender");
|
|
139
|
+
* ```
|
|
140
|
+
*/
|
|
141
|
+
export function extendServerWrapperPresets(customPresets) {
|
|
142
|
+
// Validate and normalize all custom presets
|
|
143
|
+
const normalizedCustomPresets = {};
|
|
144
|
+
for (const [key, preset] of Object.entries(customPresets)) {
|
|
145
|
+
normalizedCustomPresets[key] =
|
|
146
|
+
createServerWrapperPreset(preset);
|
|
147
|
+
}
|
|
148
|
+
const extendedPresets = {
|
|
149
|
+
...SERVER_WRAPPER_PRESETS,
|
|
150
|
+
...normalizedCustomPresets,
|
|
151
|
+
};
|
|
152
|
+
function resolvePreset(preset) {
|
|
153
|
+
if (typeof preset === "string") {
|
|
154
|
+
const resolved = extendedPresets[preset];
|
|
155
|
+
if (!resolved) {
|
|
156
|
+
throw new Error(`Unknown server wrapper preset: "${preset}". Available presets: ${Object.keys(extendedPresets).join(", ")}`);
|
|
157
|
+
}
|
|
158
|
+
return resolved;
|
|
159
|
+
}
|
|
160
|
+
// Validate and normalize inline preset
|
|
161
|
+
return createServerWrapperPreset(preset);
|
|
162
|
+
}
|
|
163
|
+
function getPresetNames() {
|
|
164
|
+
return Object.keys(extendedPresets);
|
|
165
|
+
}
|
|
166
|
+
return {
|
|
167
|
+
presets: extendedPresets,
|
|
168
|
+
resolvePreset,
|
|
169
|
+
getPresetNames,
|
|
170
|
+
};
|
|
171
|
+
}
|
|
172
|
+
//# sourceMappingURL=presets.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"presets.js","sourceRoot":"","sources":["../../src/factory/presets.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC;;;;;;;;OAQG;IACH,UAAU,EAAE;QACV,YAAY,EAAE;;;;;;;;;;;;;;8BAcY,CAAC,IAAI,EAAE;QACjC,WAAW,EAAE,8BAA8B;KAC5C;IAED;;;;;OAKG;IACH,UAAU,EAAE;QACV,oBAAoB,EAAE,IAAI;QAC1B,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BhB,CAAC,IAAI,EAAE;QACL,WAAW,EAAE,8BAA8B;KAC5C;CACO,CAAC;AAsBX;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAA2B;IAE3B,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;IACD,OAAO;QACL,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE;QACxC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;KAClD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,0BAA0B,CAExC,aAAsB;IACtB,4CAA4C;IAC5C,MAAM,uBAAuB,GAAG,EAAa,CAAC;IAC9C,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;QACzD,uBAA+D,CAAC,GAAG,CAAC;YACnE,yBAAyB,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,MAAM,eAAe,GAAG;QACtB,GAAG,sBAAsB;QACzB,GAAG,uBAAuB;KACgB,CAAC;IAI7C,SAAS,aAAa,CACpB,MAAwC;QAExC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAsC,CAAC,CAAC;YACzE,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,IAAI,KAAK,CACb,mCAAmC,MAAM,yBAAyB,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5G,CAAC;YACJ,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,uCAAuC;QACvC,OAAO,yBAAyB,CAAC,MAA6B,CAAC,CAAC;IAClE,CAAC;IAED,SAAS,cAAc;QACrB,OAAO,MAAM,CAAC,IAAI,CAAC,eAAe,CAAiB,CAAC;IACtD,CAAC;IAED,OAAO;QACL,OAAO,EAAE,eAAe;QACxB,aAAa;QACb,cAAc;KACf,CAAC;AACJ,CAAC"}
|
package/dist/factory.d.ts
CHANGED
|
@@ -15,10 +15,12 @@ export interface ServerWrapperPreset {
|
|
|
15
15
|
requiresHtmlTemplate?: boolean;
|
|
16
16
|
}
|
|
17
17
|
/**
|
|
18
|
-
* Built-in server wrapper presets
|
|
18
|
+
* Built-in server wrapper presets (generic, framework-agnostic)
|
|
19
19
|
*
|
|
20
|
-
* Note: All presets
|
|
20
|
+
* Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
|
|
21
21
|
* which are automatically provided by generateServerWrapperCode()
|
|
22
|
+
*
|
|
23
|
+
* Framework-specific presets should be defined in their respective adapter packages.
|
|
22
24
|
*/
|
|
23
25
|
export declare const SERVER_WRAPPER_PRESETS: {
|
|
24
26
|
/** Generic handler - detects default or handler export */
|
|
@@ -31,12 +33,6 @@ export declare const SERVER_WRAPPER_PRESETS: {
|
|
|
31
33
|
readonly handlerSetup: string;
|
|
32
34
|
readonly handlerCall: "serverHandler(webRequest, ...args)";
|
|
33
35
|
};
|
|
34
|
-
/** React Router - uses createRequestHandler */
|
|
35
|
-
readonly reactRouter: {
|
|
36
|
-
readonly imports: "import { createRequestHandler } from \"react-router\";";
|
|
37
|
-
readonly handlerSetup: string;
|
|
38
|
-
readonly handlerCall: "requestHandler(webRequest, ...args)";
|
|
39
|
-
};
|
|
40
36
|
/** Vite SSR - standard Vite SSR with render function */
|
|
41
37
|
readonly viteSSR: {
|
|
42
38
|
readonly requiresHtmlTemplate: true;
|
|
@@ -112,6 +108,62 @@ export declare function createFrameworkAdapter(config: AdapterFactoryConfig, opt
|
|
|
112
108
|
* Create a stateful adapter (for complex adapters needing shared state)
|
|
113
109
|
*/
|
|
114
110
|
export declare function createStatefulAdapter<TState extends object>(initialState: TState, factory: (state: TState) => FrameworkAdapter): FrameworkAdapter;
|
|
111
|
+
/**
|
|
112
|
+
* Result of extending server wrapper presets
|
|
113
|
+
*/
|
|
114
|
+
export interface ExtendedPresetsResult<TCustom extends Record<string, ServerWrapperPreset>> {
|
|
115
|
+
/** Extended presets object (core + custom) */
|
|
116
|
+
presets: typeof SERVER_WRAPPER_PRESETS & TCustom;
|
|
117
|
+
/** Type-safe preset resolver function */
|
|
118
|
+
resolvePreset: (preset: keyof (typeof SERVER_WRAPPER_PRESETS & TCustom) | ServerWrapperPreset) => ServerWrapperPreset;
|
|
119
|
+
/** Get all available preset names */
|
|
120
|
+
getPresetNames: () => (keyof (typeof SERVER_WRAPPER_PRESETS & TCustom))[];
|
|
121
|
+
}
|
|
122
|
+
/**
|
|
123
|
+
* Create a server wrapper preset
|
|
124
|
+
*
|
|
125
|
+
* Helper function to create a properly typed preset with validation and normalization.
|
|
126
|
+
* Automatically trims handlerSetup and validates required fields.
|
|
127
|
+
*
|
|
128
|
+
* @example
|
|
129
|
+
* ```ts
|
|
130
|
+
* const myPreset = createServerWrapperPreset({
|
|
131
|
+
* imports: `import { handler } from 'my-framework';`,
|
|
132
|
+
* handlerSetup: `const requestHandler = handler(serverExports);`,
|
|
133
|
+
* handlerCall: "requestHandler(webRequest)",
|
|
134
|
+
* });
|
|
135
|
+
* ```
|
|
136
|
+
*/
|
|
137
|
+
export declare function createServerWrapperPreset(config: ServerWrapperPreset): ServerWrapperPreset;
|
|
138
|
+
/**
|
|
139
|
+
* Extend core server wrapper presets with custom presets
|
|
140
|
+
*
|
|
141
|
+
* This utility provides a standardized way for adapters to:
|
|
142
|
+
* 1. Add framework-specific presets while keeping core presets
|
|
143
|
+
* 2. Get a type-safe resolver function
|
|
144
|
+
* 3. Export extended presets for external use
|
|
145
|
+
*
|
|
146
|
+
* Custom presets are automatically validated and normalized using createServerWrapperPreset().
|
|
147
|
+
*
|
|
148
|
+
* @example
|
|
149
|
+
* ```ts
|
|
150
|
+
* // In vite-adapter - can pass raw config, will be validated automatically
|
|
151
|
+
* const { presets, resolvePreset } = extendServerWrapperPresets({
|
|
152
|
+
* vike: {
|
|
153
|
+
* imports: `import { renderPage } from 'vike/server';`,
|
|
154
|
+
* handlerSetup: `...`,
|
|
155
|
+
* handlerCall: "handleVikeRequest(webRequest)",
|
|
156
|
+
* },
|
|
157
|
+
* });
|
|
158
|
+
*
|
|
159
|
+
* export const SERVER_WRAPPER_PRESETS = presets;
|
|
160
|
+
* export type ServerWrapperPresetName = keyof typeof presets;
|
|
161
|
+
*
|
|
162
|
+
* // Use in adapter
|
|
163
|
+
* const resolved = resolvePreset(options.serverWrapper || "viteSSR");
|
|
164
|
+
* ```
|
|
165
|
+
*/
|
|
166
|
+
export declare function extendServerWrapperPresets<TCustom extends Record<string, ServerWrapperPreset>>(customPresets: TCustom): ExtendedPresetsResult<TCustom>;
|
|
115
167
|
/**
|
|
116
168
|
* Combine multiple detector functions (returns true if any matches)
|
|
117
169
|
*/
|
package/dist/factory.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,YAAY,EAEZ,SAAS,EAET,gBAAgB,EAGjB,MAAM,YAAY,CAAC;
|
|
1
|
+
{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"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"}
|
package/dist/factory.js
CHANGED
|
@@ -5,12 +5,15 @@
|
|
|
5
5
|
*/
|
|
6
6
|
import path from "path";
|
|
7
7
|
import { pathExists, readFile, detectConfigFile, detectBuildDir, detectServerEntry, generateServerWrapperCode, createDefaultMeta, logBuildArtifacts, } from "./utils.js";
|
|
8
|
+
import { ViteConfigParser, } from "./vite-config-parser.js";
|
|
8
9
|
import { parseRoutesFromSources, } from "./route-parser.js";
|
|
9
10
|
/**
|
|
10
|
-
* Built-in server wrapper presets
|
|
11
|
+
* Built-in server wrapper presets (generic, framework-agnostic)
|
|
11
12
|
*
|
|
12
|
-
* Note: All presets
|
|
13
|
+
* Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
|
|
13
14
|
* which are automatically provided by generateServerWrapperCode()
|
|
15
|
+
*
|
|
16
|
+
* Framework-specific presets should be defined in their respective adapter packages.
|
|
14
17
|
*/
|
|
15
18
|
export const SERVER_WRAPPER_PRESETS = {
|
|
16
19
|
/** Generic handler - detects default or handler export */
|
|
@@ -39,40 +42,6 @@ const getHandler = () => {
|
|
|
39
42
|
const serverHandler = getHandler();`.trim(),
|
|
40
43
|
handlerCall: "serverHandler(webRequest, ...args)",
|
|
41
44
|
},
|
|
42
|
-
/** React Router - uses createRequestHandler */
|
|
43
|
-
reactRouter: {
|
|
44
|
-
imports: `import { createRequestHandler } from "react-router";`,
|
|
45
|
-
handlerSetup: `
|
|
46
|
-
// Extract React Router server build exports
|
|
47
|
-
const {
|
|
48
|
-
routes,
|
|
49
|
-
serverManifest,
|
|
50
|
-
assetsBuildDirectory,
|
|
51
|
-
basename,
|
|
52
|
-
entry,
|
|
53
|
-
future,
|
|
54
|
-
isSpaMode,
|
|
55
|
-
publicPath,
|
|
56
|
-
routeDiscovery,
|
|
57
|
-
ssr
|
|
58
|
-
} = serverExports;
|
|
59
|
-
|
|
60
|
-
const buildConfig = {
|
|
61
|
-
assets: serverManifest,
|
|
62
|
-
assetsBuildDirectory,
|
|
63
|
-
basename,
|
|
64
|
-
entry,
|
|
65
|
-
future,
|
|
66
|
-
isSpaMode,
|
|
67
|
-
publicPath,
|
|
68
|
-
routes,
|
|
69
|
-
routeDiscovery,
|
|
70
|
-
ssr
|
|
71
|
-
};
|
|
72
|
-
|
|
73
|
-
const requestHandler = createRequestHandler(buildConfig);`.trim(),
|
|
74
|
-
handlerCall: "requestHandler(webRequest, ...args)",
|
|
75
|
-
},
|
|
76
45
|
/** Vite SSR - standard Vite SSR with render function */
|
|
77
46
|
viteSSR: {
|
|
78
47
|
requiresHtmlTemplate: true,
|
|
@@ -124,11 +93,23 @@ function createDefaultDetector(configFiles) {
|
|
|
124
93
|
}
|
|
125
94
|
/**
|
|
126
95
|
* Create default getBuildArtifacts function
|
|
96
|
+
* Uses ViteConfigParser for comprehensive Vite config support:
|
|
97
|
+
* - build.outDir: custom output directory
|
|
98
|
+
* - build.assetsDir: static assets directory name
|
|
99
|
+
* - build.ssr: SSR entry point
|
|
100
|
+
* - build.manifest: manifest.json generation
|
|
101
|
+
* - base: public base path
|
|
102
|
+
* - rollupOptions.input: entry file(s)
|
|
103
|
+
* - rollupOptions.output.dir: output directory override
|
|
104
|
+
* - rollupOptions.output.entryFileNames: output filename pattern
|
|
105
|
+
* - rollupOptions.output.assetFileNames: asset filename pattern
|
|
106
|
+
* - rollupOptions.output.chunkFileNames: chunk filename pattern
|
|
127
107
|
*/
|
|
128
108
|
function createDefaultBuildArtifactsGetter(name, buildDirs, serverEntryFiles, options) {
|
|
129
109
|
const { clientBuildDir, serverBuildDir, serverEntry } = options;
|
|
130
110
|
return async (context) => {
|
|
131
|
-
const { projectRoot, isSSR, logger } = context;
|
|
111
|
+
const { projectRoot, isSSR, logger, viteConfig } = context;
|
|
112
|
+
// Resolve client directory
|
|
132
113
|
let clientDir = null;
|
|
133
114
|
if (clientBuildDir) {
|
|
134
115
|
clientDir = path.join(projectRoot, clientBuildDir);
|
|
@@ -139,17 +120,61 @@ function createDefaultBuildArtifactsGetter(name, buildDirs, serverEntryFiles, op
|
|
|
139
120
|
let serverDir = null;
|
|
140
121
|
let serverEntryPath = null;
|
|
141
122
|
if (isSSR && buildDirs.server) {
|
|
142
|
-
|
|
143
|
-
|
|
123
|
+
// Use ViteConfigParser for comprehensive config support
|
|
124
|
+
if (viteConfig) {
|
|
125
|
+
const configParser = new ViteConfigParser(viteConfig, projectRoot, {
|
|
126
|
+
logger,
|
|
127
|
+
serverEntryCandidates: serverEntryFiles,
|
|
128
|
+
});
|
|
129
|
+
// Priority 1: Explicit serverBuildDir option
|
|
130
|
+
if (serverBuildDir) {
|
|
131
|
+
serverDir = path.join(projectRoot, serverBuildDir);
|
|
132
|
+
}
|
|
133
|
+
else {
|
|
134
|
+
// Priority 2: Get from Vite config using parser
|
|
135
|
+
serverDir = configParser.getServerDir();
|
|
136
|
+
}
|
|
137
|
+
// Priority 3: Fall back to predefined build directories
|
|
138
|
+
if (!serverDir) {
|
|
139
|
+
serverDir = await detectBuildDir(projectRoot, buildDirs.server);
|
|
140
|
+
}
|
|
141
|
+
// Find server entry
|
|
142
|
+
if (serverEntry) {
|
|
143
|
+
// Explicit server entry path provided
|
|
144
|
+
serverEntryPath = path.join(projectRoot, serverEntry);
|
|
145
|
+
}
|
|
146
|
+
else if (serverDir) {
|
|
147
|
+
// Priority 1: Try to get server entry from Vite config using parser
|
|
148
|
+
serverEntryPath = await configParser.findServerEntry(serverDir);
|
|
149
|
+
if (serverEntryPath) {
|
|
150
|
+
logger.verbose(`Using server entry from Vite config: ${serverEntryPath}`);
|
|
151
|
+
}
|
|
152
|
+
// Priority 2: Fall back to file detection with recursive search
|
|
153
|
+
if (!serverEntryPath) {
|
|
154
|
+
serverEntryPath = await detectServerEntry(serverDir, serverEntryFiles, {
|
|
155
|
+
recursive: true,
|
|
156
|
+
logger,
|
|
157
|
+
});
|
|
158
|
+
}
|
|
159
|
+
}
|
|
144
160
|
}
|
|
145
161
|
else {
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
162
|
+
// No Vite config available, use fallback detection
|
|
163
|
+
if (serverBuildDir) {
|
|
164
|
+
serverDir = path.join(projectRoot, serverBuildDir);
|
|
165
|
+
}
|
|
166
|
+
else {
|
|
167
|
+
serverDir = await detectBuildDir(projectRoot, buildDirs.server);
|
|
168
|
+
}
|
|
169
|
+
if (serverEntry) {
|
|
170
|
+
serverEntryPath = path.join(projectRoot, serverEntry);
|
|
171
|
+
}
|
|
172
|
+
else if (serverDir) {
|
|
173
|
+
serverEntryPath = await detectServerEntry(serverDir, serverEntryFiles, {
|
|
174
|
+
recursive: true,
|
|
175
|
+
logger,
|
|
176
|
+
});
|
|
177
|
+
}
|
|
153
178
|
}
|
|
154
179
|
}
|
|
155
180
|
logBuildArtifacts(logger, name, {
|
|
@@ -317,6 +342,94 @@ export function createFrameworkAdapter(config, options = {}, overrides) {
|
|
|
317
342
|
export function createStatefulAdapter(initialState, factory) {
|
|
318
343
|
return factory({ ...initialState });
|
|
319
344
|
}
|
|
345
|
+
/**
|
|
346
|
+
* Create a server wrapper preset
|
|
347
|
+
*
|
|
348
|
+
* Helper function to create a properly typed preset with validation and normalization.
|
|
349
|
+
* Automatically trims handlerSetup and validates required fields.
|
|
350
|
+
*
|
|
351
|
+
* @example
|
|
352
|
+
* ```ts
|
|
353
|
+
* const myPreset = createServerWrapperPreset({
|
|
354
|
+
* imports: `import { handler } from 'my-framework';`,
|
|
355
|
+
* handlerSetup: `const requestHandler = handler(serverExports);`,
|
|
356
|
+
* handlerCall: "requestHandler(webRequest)",
|
|
357
|
+
* });
|
|
358
|
+
* ```
|
|
359
|
+
*/
|
|
360
|
+
export function createServerWrapperPreset(config) {
|
|
361
|
+
if (!config.handlerSetup) {
|
|
362
|
+
throw new Error("Server wrapper preset must have handlerSetup");
|
|
363
|
+
}
|
|
364
|
+
if (!config.handlerCall) {
|
|
365
|
+
throw new Error("Server wrapper preset must have handlerCall");
|
|
366
|
+
}
|
|
367
|
+
return {
|
|
368
|
+
imports: config.imports,
|
|
369
|
+
handlerSetup: config.handlerSetup.trim(),
|
|
370
|
+
handlerCall: config.handlerCall,
|
|
371
|
+
requiresHtmlTemplate: config.requiresHtmlTemplate,
|
|
372
|
+
};
|
|
373
|
+
}
|
|
374
|
+
/**
|
|
375
|
+
* Extend core server wrapper presets with custom presets
|
|
376
|
+
*
|
|
377
|
+
* This utility provides a standardized way for adapters to:
|
|
378
|
+
* 1. Add framework-specific presets while keeping core presets
|
|
379
|
+
* 2. Get a type-safe resolver function
|
|
380
|
+
* 3. Export extended presets for external use
|
|
381
|
+
*
|
|
382
|
+
* Custom presets are automatically validated and normalized using createServerWrapperPreset().
|
|
383
|
+
*
|
|
384
|
+
* @example
|
|
385
|
+
* ```ts
|
|
386
|
+
* // In vite-adapter - can pass raw config, will be validated automatically
|
|
387
|
+
* const { presets, resolvePreset } = extendServerWrapperPresets({
|
|
388
|
+
* vike: {
|
|
389
|
+
* imports: `import { renderPage } from 'vike/server';`,
|
|
390
|
+
* handlerSetup: `...`,
|
|
391
|
+
* handlerCall: "handleVikeRequest(webRequest)",
|
|
392
|
+
* },
|
|
393
|
+
* });
|
|
394
|
+
*
|
|
395
|
+
* export const SERVER_WRAPPER_PRESETS = presets;
|
|
396
|
+
* export type ServerWrapperPresetName = keyof typeof presets;
|
|
397
|
+
*
|
|
398
|
+
* // Use in adapter
|
|
399
|
+
* const resolved = resolvePreset(options.serverWrapper || "viteSSR");
|
|
400
|
+
* ```
|
|
401
|
+
*/
|
|
402
|
+
export function extendServerWrapperPresets(customPresets) {
|
|
403
|
+
// Validate and normalize all custom presets
|
|
404
|
+
const normalizedCustomPresets = {};
|
|
405
|
+
for (const [key, preset] of Object.entries(customPresets)) {
|
|
406
|
+
normalizedCustomPresets[key] =
|
|
407
|
+
createServerWrapperPreset(preset);
|
|
408
|
+
}
|
|
409
|
+
const extendedPresets = {
|
|
410
|
+
...SERVER_WRAPPER_PRESETS,
|
|
411
|
+
...normalizedCustomPresets,
|
|
412
|
+
};
|
|
413
|
+
function resolvePreset(preset) {
|
|
414
|
+
if (typeof preset === "string") {
|
|
415
|
+
const resolved = extendedPresets[preset];
|
|
416
|
+
if (!resolved) {
|
|
417
|
+
throw new Error(`Unknown server wrapper preset: "${preset}". Available presets: ${Object.keys(extendedPresets).join(", ")}`);
|
|
418
|
+
}
|
|
419
|
+
return resolved;
|
|
420
|
+
}
|
|
421
|
+
// Validate and normalize inline preset
|
|
422
|
+
return createServerWrapperPreset(preset);
|
|
423
|
+
}
|
|
424
|
+
function getPresetNames() {
|
|
425
|
+
return Object.keys(extendedPresets);
|
|
426
|
+
}
|
|
427
|
+
return {
|
|
428
|
+
presets: extendedPresets,
|
|
429
|
+
resolvePreset,
|
|
430
|
+
getPresetNames,
|
|
431
|
+
};
|
|
432
|
+
}
|
|
320
433
|
/**
|
|
321
434
|
* Combine multiple detector functions (returns true if any matches)
|
|
322
435
|
*/
|