@storybook/tanstack-react 0.0.0-pr-34403-sha-effaf693 → 0.0.0-pr-34403-sha-da307159
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/_browser-chunks/{chunk-LJRZDJ5L.js → chunk-IAMEPSEQ.js} +29 -20
- package/dist/export-mocks/start-server.d.ts +95 -0
- package/dist/export-mocks/start-server.js +291 -0
- package/dist/export-mocks/start-storage-context.d.ts +16 -0
- package/dist/export-mocks/start-storage-context.js +33 -0
- package/dist/export-mocks/start.d.ts +13 -1
- package/dist/export-mocks/start.js +17 -1
- package/dist/index.d.ts +49 -18
- package/dist/index.js +1 -1
- package/dist/node/index.js +6 -6
- package/dist/preset.js +208 -10
- package/dist/preview.d.ts +48 -15
- package/dist/preview.js +1 -1
- package/package.json +17 -5
|
@@ -29,8 +29,21 @@ function isRoute(value) {
|
|
|
29
29
|
function getRouteFromContext(Story, context) {
|
|
30
30
|
let metaRoute = context.route, routerParameters = context.parameters.tanstack?.router ?? {}, routerParameterRoute = routerParameters.route, { route: _route, ...routeOverrides } = routerParameters ?? {}, resolvedRoute = isRoute(routerParameterRoute) ? routerParameterRoute : isRoute(metaRoute) ? metaRoute : void 0;
|
|
31
31
|
if (resolvedRoute instanceof RootRoute) {
|
|
32
|
-
let children = resolvedRoute.children;
|
|
33
|
-
|
|
32
|
+
let clonedRoot = createRootRoute({ ...resolvedRoute.options }), children = resolvedRoute.children;
|
|
33
|
+
if (children?.length) {
|
|
34
|
+
let clonedChildren = children.map((child2) => {
|
|
35
|
+
let { id: _id, getParentRoute: _g, ...childOpts } = child2.options ?? {};
|
|
36
|
+
return createRoute({
|
|
37
|
+
...childOpts,
|
|
38
|
+
...routeOverrides,
|
|
39
|
+
component: () => React.createElement(Story, null),
|
|
40
|
+
getParentRoute: () => clonedRoot
|
|
41
|
+
});
|
|
42
|
+
});
|
|
43
|
+
clonedRoot.addChildren(clonedChildren);
|
|
44
|
+
} else
|
|
45
|
+
clonedRoot.update({ component: () => React.createElement(Story, null), ...routeOverrides });
|
|
46
|
+
return clonedRoot;
|
|
34
47
|
}
|
|
35
48
|
if (resolvedRoute instanceof Route) {
|
|
36
49
|
let root2 = createRootRoute(), { id: _id, ...routeOpts } = resolvedRoute.options ?? {}, child2 = createRoute({
|
|
@@ -50,7 +63,7 @@ function getRouteFromContext(Story, context) {
|
|
|
50
63
|
return root.addChildren([child]), root;
|
|
51
64
|
}
|
|
52
65
|
function createStoryRouter({ Story, context }) {
|
|
53
|
-
let routerParameters = context.parameters.tanstack?.router ?? {}, routeTree = getRouteFromContext(Story, context), initialPath = (routerParameters?.path || routeTree.children[0]?.fullPath || routeTree.children[0]?.path || routeTree.children[0]?.options?.path) ?? "/", resolvedPath = interpolatePath({
|
|
66
|
+
let routerParameters = context.parameters.tanstack?.router ?? {}, routeTree = getRouteFromContext(Story, context), initialPath = (routerParameters?.path || routeTree.children?.[0]?.fullPath || routeTree.children?.[0]?.path || routeTree.children?.[0]?.options?.path) ?? "/", resolvedPath = interpolatePath({
|
|
54
67
|
path: initialPath,
|
|
55
68
|
params: routerParameters?.params ?? {}
|
|
56
69
|
}).interpolatedPath, search = routerParameters?.query ? defaultStringifySearch(routerParameters.query) : "";
|
|
@@ -79,24 +92,20 @@ import { Route as Route2, RootRoute as RootRoute2 } from "@tanstack/react-router
|
|
|
79
92
|
function isRoute2(value) {
|
|
80
93
|
return value instanceof Route2 || value instanceof RootRoute2;
|
|
81
94
|
}
|
|
95
|
+
function getComponentFromRoute(route) {
|
|
96
|
+
if (route.options?.component)
|
|
97
|
+
return route.options.component;
|
|
98
|
+
if (route instanceof RootRoute2)
|
|
99
|
+
return route.children?.[0]?.options?.component;
|
|
100
|
+
}
|
|
82
101
|
var routeComponentLoader = (context) => {
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
"loaderDeps",
|
|
91
|
-
"context",
|
|
92
|
-
"params",
|
|
93
|
-
"head",
|
|
94
|
-
"search",
|
|
95
|
-
"parseParams"
|
|
96
|
-
], overrides = {};
|
|
97
|
-
for (let key of routeOptionKeys)
|
|
98
|
-
key in (context.args ?? {}) && context.args[key] !== void 0 && (overrides[key] = context.args[key]);
|
|
99
|
-
Object.keys(overrides).length > 0 && route.update(overrides);
|
|
102
|
+
let componentRoute = isRoute2(context.component) ? context.component : void 0, routerParameters = context.parameters.tanstack?.router ?? {}, resolvedRoute = (isRoute2(routerParameters.route) ? routerParameters.route : void 0) ?? componentRoute;
|
|
103
|
+
if (resolvedRoute) {
|
|
104
|
+
if (!context.component) {
|
|
105
|
+
let component = getComponentFromRoute(resolvedRoute);
|
|
106
|
+
component && (componentRoute || !context.component) && (context.component = component);
|
|
107
|
+
}
|
|
108
|
+
context.route || (context.route = resolvedRoute);
|
|
100
109
|
}
|
|
101
110
|
};
|
|
102
111
|
|
|
@@ -0,0 +1,95 @@
|
|
|
1
|
+
type RequestOptions<TRegister = unknown> = {
|
|
2
|
+
context?: TRegister extends {
|
|
3
|
+
server: {
|
|
4
|
+
requestContext: infer TRequestContext;
|
|
5
|
+
};
|
|
6
|
+
} ? TRequestContext : unknown;
|
|
7
|
+
};
|
|
8
|
+
type MockRequestExecutor<TRegister = unknown> = (request: Request, opts?: RequestOptions<TRegister>) => Promise<unknown> | unknown;
|
|
9
|
+
type HandlerContext = {
|
|
10
|
+
request: Request;
|
|
11
|
+
responseHeaders: Headers;
|
|
12
|
+
router?: unknown;
|
|
13
|
+
context?: unknown;
|
|
14
|
+
requestContext?: unknown;
|
|
15
|
+
};
|
|
16
|
+
type HandlerCallback<TRouter = unknown> = (context: HandlerContext & {
|
|
17
|
+
router?: TRouter;
|
|
18
|
+
}) => Promise<unknown> | unknown;
|
|
19
|
+
type SessionConfig = Record<string, unknown>;
|
|
20
|
+
type MockSession<TSessionData extends Record<string, unknown> = Record<string, unknown>> = {
|
|
21
|
+
data: Partial<TSessionData>;
|
|
22
|
+
update: (update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
|
|
23
|
+
save: () => Promise<void>;
|
|
24
|
+
clear: () => Promise<void>;
|
|
25
|
+
};
|
|
26
|
+
declare const HEADERS: {
|
|
27
|
+
readonly TSS_SHELL: "X-TSS_SHELL";
|
|
28
|
+
};
|
|
29
|
+
declare const VIRTUAL_MODULES: {
|
|
30
|
+
readonly startManifest: "tanstack-start-manifest:v";
|
|
31
|
+
readonly injectedHeadScripts: "tanstack-start-injected-head-scripts:v";
|
|
32
|
+
readonly serverFnResolver: "#tanstack-start-server-fn-resolver";
|
|
33
|
+
};
|
|
34
|
+
declare function StartServer(): null;
|
|
35
|
+
declare const defineHandlerCallback: <TRouter = unknown>(handler: HandlerCallback<TRouter>) => HandlerCallback<TRouter>;
|
|
36
|
+
declare const defaultStreamHandler: () => Promise<Response>;
|
|
37
|
+
declare const defaultRenderHandler: () => Promise<Response>;
|
|
38
|
+
declare const requestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister>) => Promise<Response>;
|
|
39
|
+
declare const createRequestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
|
|
40
|
+
declare const createStartHandler: <TRegister = unknown>(cbOrOptions: HandlerCallback | {
|
|
41
|
+
handler?: HandlerCallback;
|
|
42
|
+
}) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
|
|
43
|
+
declare const attachRouterServerSsrUtils: <TRouter>(router: TRouter) => TRouter;
|
|
44
|
+
declare const transformReadableStreamWithRouter: <TReadableStream>(stream: TReadableStream) => TReadableStream;
|
|
45
|
+
declare const transformPipeableStreamWithRouter: <TPipeableStream>(stream: TPipeableStream) => TPipeableStream;
|
|
46
|
+
declare const getRequest: () => Request;
|
|
47
|
+
declare const getRequestHeaders: () => Headers;
|
|
48
|
+
declare const getRequestHeader: (name: string) => string | undefined;
|
|
49
|
+
declare const getRequestIP: (opts?: {
|
|
50
|
+
xForwardedFor?: boolean;
|
|
51
|
+
}) => string | undefined;
|
|
52
|
+
declare const getRequestHost: (opts?: {
|
|
53
|
+
xForwardedHost?: boolean;
|
|
54
|
+
}) => string;
|
|
55
|
+
declare const getRequestUrl: (opts?: {
|
|
56
|
+
xForwardedHost?: boolean;
|
|
57
|
+
xForwardedProto?: boolean;
|
|
58
|
+
}) => URL;
|
|
59
|
+
declare const getRequestProtocol: (opts?: {
|
|
60
|
+
xForwardedProto?: boolean;
|
|
61
|
+
}) => string;
|
|
62
|
+
declare const setResponseHeaders: (headers: HeadersInit) => void;
|
|
63
|
+
declare const getResponseHeaders: () => Headers;
|
|
64
|
+
declare const getResponseHeader: (name: string) => string | undefined;
|
|
65
|
+
declare const setResponseHeader: (name: string, value: string | Array<string>) => void;
|
|
66
|
+
declare const removeResponseHeader: (name: string) => void;
|
|
67
|
+
declare const clearResponseHeaders: (headerNames?: Array<string>) => void;
|
|
68
|
+
declare const getResponseStatus: () => number;
|
|
69
|
+
declare const setResponseStatus: (code?: number, text?: string) => void;
|
|
70
|
+
declare const getCookies: () => {
|
|
71
|
+
[k: string]: string;
|
|
72
|
+
};
|
|
73
|
+
declare const getCookie: (name: string) => string | undefined;
|
|
74
|
+
declare const setCookie: (name: string, value: string, options?: Record<string, unknown>) => void;
|
|
75
|
+
declare const deleteCookie: (name: string, options?: Record<string, unknown>) => void;
|
|
76
|
+
declare const useSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
|
|
77
|
+
declare const getSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
|
|
78
|
+
declare const updateSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig, update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
|
|
79
|
+
declare const sealSession: (_config: SessionConfig) => Promise<string>;
|
|
80
|
+
declare const unsealSession: (_config: SessionConfig, sealed: string) => Promise<any>;
|
|
81
|
+
declare const clearSession: (_config: Partial<SessionConfig>) => Promise<void>;
|
|
82
|
+
declare const getResponse: () => {
|
|
83
|
+
status: number | undefined;
|
|
84
|
+
statusText: string | undefined;
|
|
85
|
+
readonly headers: Headers;
|
|
86
|
+
};
|
|
87
|
+
declare const getValidatedQuery: (schema: {
|
|
88
|
+
parse?: (value: Record<string, string>) => unknown;
|
|
89
|
+
safeParse?: (value: Record<string, string>) => unknown;
|
|
90
|
+
["~standard"]?: {
|
|
91
|
+
validate?: (value: Record<string, string>) => Promise<unknown> | unknown;
|
|
92
|
+
};
|
|
93
|
+
}) => Promise<unknown>;
|
|
94
|
+
|
|
95
|
+
export { HEADERS, StartServer, VIRTUAL_MODULES, attachRouterServerSsrUtils, clearResponseHeaders, clearSession, createRequestHandler, createStartHandler, defaultRenderHandler, defaultStreamHandler, defineHandlerCallback, deleteCookie, getCookie, getCookies, getRequest, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestProtocol, getRequestUrl, getResponse, getResponseHeader, getResponseHeaders, getResponseStatus, getSession, getValidatedQuery, removeResponseHeader, requestHandler, sealSession, setCookie, setResponseHeader, setResponseHeaders, setResponseStatus, transformPipeableStreamWithRouter, transformReadableStreamWithRouter, unsealSession, updateSession, useSession };
|
|
@@ -0,0 +1,291 @@
|
|
|
1
|
+
import "../_browser-chunks/chunk-4BE7D4DS.js";
|
|
2
|
+
|
|
3
|
+
// src/export-mocks/start-server.ts
|
|
4
|
+
import { fn } from "storybook/test";
|
|
5
|
+
var START_SERVER_STATE_SYMBOL = Symbol.for("storybook.tanstack-react.start-server.state"), browserGlobals = globalThis, HEADERS = {
|
|
6
|
+
TSS_SHELL: "X-TSS_SHELL"
|
|
7
|
+
}, VIRTUAL_MODULES = {
|
|
8
|
+
startManifest: "tanstack-start-manifest:v",
|
|
9
|
+
injectedHeadScripts: "tanstack-start-injected-head-scripts:v",
|
|
10
|
+
serverFnResolver: "#tanstack-start-server-fn-resolver"
|
|
11
|
+
};
|
|
12
|
+
function createNamedMock(name, implementation) {
|
|
13
|
+
return fn(implementation).mockName(`@tanstack/react-start/server::${name}`);
|
|
14
|
+
}
|
|
15
|
+
function createDefaultRequest() {
|
|
16
|
+
return new Request("http://localhost/");
|
|
17
|
+
}
|
|
18
|
+
function parseCookieHeader(cookieHeader) {
|
|
19
|
+
let cookies = /* @__PURE__ */ new Map();
|
|
20
|
+
if (!cookieHeader)
|
|
21
|
+
return cookies;
|
|
22
|
+
for (let segment of cookieHeader.split(";")) {
|
|
23
|
+
let [rawName, ...rawValue] = segment.trim().split("=");
|
|
24
|
+
rawName && cookies.set(rawName, decodeURIComponent(rawValue.join("=")));
|
|
25
|
+
}
|
|
26
|
+
return cookies;
|
|
27
|
+
}
|
|
28
|
+
function serializeCookie(name, value, options) {
|
|
29
|
+
let parts = [`${name}=${encodeURIComponent(value)}`];
|
|
30
|
+
return typeof options?.path == "string" && parts.push(`Path=${options.path}`), typeof options?.domain == "string" && parts.push(`Domain=${options.domain}`), typeof options?.maxAge == "number" && parts.push(`Max-Age=${options.maxAge}`), options?.expires instanceof Date && parts.push(`Expires=${options.expires.toUTCString()}`), options?.httpOnly && parts.push("HttpOnly"), options?.secure && parts.push("Secure"), typeof options?.sameSite == "string" && parts.push(`SameSite=${options.sameSite}`), parts.join("; ");
|
|
31
|
+
}
|
|
32
|
+
function createMockState(request = createDefaultRequest()) {
|
|
33
|
+
return {
|
|
34
|
+
request,
|
|
35
|
+
responseHeaders: new Headers(),
|
|
36
|
+
responseStatus: void 0,
|
|
37
|
+
cookies: parseCookieHeader(request.headers.get("cookie")),
|
|
38
|
+
sessionData: {}
|
|
39
|
+
};
|
|
40
|
+
}
|
|
41
|
+
function getState() {
|
|
42
|
+
let existingState = browserGlobals[START_SERVER_STATE_SYMBOL];
|
|
43
|
+
if (existingState)
|
|
44
|
+
return existingState;
|
|
45
|
+
let nextState = createMockState();
|
|
46
|
+
return browserGlobals[START_SERVER_STATE_SYMBOL] = nextState, nextState;
|
|
47
|
+
}
|
|
48
|
+
async function withRequestState(request, run) {
|
|
49
|
+
let previousState = browserGlobals[START_SERVER_STATE_SYMBOL];
|
|
50
|
+
browserGlobals[START_SERVER_STATE_SYMBOL] = createMockState(request);
|
|
51
|
+
try {
|
|
52
|
+
return await run();
|
|
53
|
+
} finally {
|
|
54
|
+
previousState ? browserGlobals[START_SERVER_STATE_SYMBOL] = previousState : delete browserGlobals[START_SERVER_STATE_SYMBOL];
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
function mergeResponseState(response) {
|
|
58
|
+
let state = getState(), headers = new Headers(response.headers);
|
|
59
|
+
return state.responseHeaders.forEach((value, key) => {
|
|
60
|
+
if (key.toLowerCase() === "set-cookie") {
|
|
61
|
+
headers.append(key, value);
|
|
62
|
+
return;
|
|
63
|
+
}
|
|
64
|
+
headers.set(key, value);
|
|
65
|
+
}), new Response(response.body, {
|
|
66
|
+
status: state.responseStatus?.code ?? response.status,
|
|
67
|
+
statusText: state.responseStatus?.text ?? response.statusText,
|
|
68
|
+
headers
|
|
69
|
+
});
|
|
70
|
+
}
|
|
71
|
+
function toResponse(result) {
|
|
72
|
+
return result instanceof Response ? mergeResponseState(result) : result == null ? mergeResponseState(new Response(null)) : mergeResponseState(typeof result == "string" ? new Response(result) : new Response(JSON.stringify(result), {
|
|
73
|
+
headers: { "content-type": "application/json" }
|
|
74
|
+
}));
|
|
75
|
+
}
|
|
76
|
+
function getSessionRecord() {
|
|
77
|
+
let state = getState();
|
|
78
|
+
return {
|
|
79
|
+
data: state.sessionData,
|
|
80
|
+
update: async (update) => {
|
|
81
|
+
let nextValue = typeof update == "function" ? update(state.sessionData) : update;
|
|
82
|
+
return state.sessionData = {
|
|
83
|
+
...state.sessionData,
|
|
84
|
+
...nextValue ?? {}
|
|
85
|
+
}, getSessionRecord();
|
|
86
|
+
},
|
|
87
|
+
save: async () => {
|
|
88
|
+
},
|
|
89
|
+
clear: async () => {
|
|
90
|
+
state.sessionData = {};
|
|
91
|
+
}
|
|
92
|
+
};
|
|
93
|
+
}
|
|
94
|
+
function StartServer() {
|
|
95
|
+
return null;
|
|
96
|
+
}
|
|
97
|
+
var defineHandlerCallback = createNamedMock(
|
|
98
|
+
"defineHandlerCallback",
|
|
99
|
+
(handler) => handler
|
|
100
|
+
), defaultStreamHandler = createNamedMock(
|
|
101
|
+
"defaultStreamHandler",
|
|
102
|
+
async () => new Response("Storybook Mock", { status: 200 })
|
|
103
|
+
), defaultRenderHandler = createNamedMock(
|
|
104
|
+
"defaultRenderHandler",
|
|
105
|
+
async () => new Response("Storybook Mock", { status: 200 })
|
|
106
|
+
), requestHandler = createNamedMock(
|
|
107
|
+
"requestHandler",
|
|
108
|
+
(handler) => async (request, requestOpts) => withRequestState(request, async () => toResponse(await handler(request, requestOpts)))
|
|
109
|
+
), createRequestHandler = createNamedMock(
|
|
110
|
+
"createRequestHandler",
|
|
111
|
+
(handler) => requestHandler(handler)
|
|
112
|
+
), createStartHandler = createNamedMock(
|
|
113
|
+
"createStartHandler",
|
|
114
|
+
(cbOrOptions) => {
|
|
115
|
+
let handler = typeof cbOrOptions == "function" ? cbOrOptions : cbOrOptions?.handler;
|
|
116
|
+
return requestHandler(async (request, requestOpts) => handler ? handler({
|
|
117
|
+
request,
|
|
118
|
+
responseHeaders: getState().responseHeaders,
|
|
119
|
+
router: browserGlobals.__TSR_ROUTER__,
|
|
120
|
+
context: requestOpts?.context,
|
|
121
|
+
requestContext: requestOpts?.context
|
|
122
|
+
}) : new Response("Storybook Mock", { status: 200 }));
|
|
123
|
+
}
|
|
124
|
+
), attachRouterServerSsrUtils = createNamedMock(
|
|
125
|
+
"attachRouterServerSsrUtils",
|
|
126
|
+
(router) => router
|
|
127
|
+
), transformReadableStreamWithRouter = createNamedMock(
|
|
128
|
+
"transformReadableStreamWithRouter",
|
|
129
|
+
(stream) => stream
|
|
130
|
+
), transformPipeableStreamWithRouter = createNamedMock(
|
|
131
|
+
"transformPipeableStreamWithRouter",
|
|
132
|
+
(stream) => stream
|
|
133
|
+
), getRequest = createNamedMock("getRequest", () => getState().request), getRequestHeaders = createNamedMock(
|
|
134
|
+
"getRequestHeaders",
|
|
135
|
+
() => getState().request.headers
|
|
136
|
+
), getRequestHeader = createNamedMock("getRequestHeader", (name) => getState().request.headers.get(name) ?? void 0), getRequestIP = createNamedMock(
|
|
137
|
+
"getRequestIP",
|
|
138
|
+
(opts) => {
|
|
139
|
+
if (opts?.xForwardedFor)
|
|
140
|
+
return getRequestHeader("x-forwarded-for")?.split(",")[0]?.trim();
|
|
141
|
+
}
|
|
142
|
+
), getRequestHost = createNamedMock(
|
|
143
|
+
"getRequestHost",
|
|
144
|
+
(opts) => (opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : getRequestHeader("host")) ?? new URL(getState().request.url).host ?? "localhost"
|
|
145
|
+
), getRequestUrl = createNamedMock(
|
|
146
|
+
"getRequestUrl",
|
|
147
|
+
(opts) => {
|
|
148
|
+
let url = new URL(getState().request.url), forwardedHost = opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : void 0, forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
|
|
149
|
+
return forwardedHost && (url.host = forwardedHost), forwardedProto && (url.protocol = `${forwardedProto}:`), url;
|
|
150
|
+
}
|
|
151
|
+
), getRequestProtocol = createNamedMock(
|
|
152
|
+
"getRequestProtocol",
|
|
153
|
+
(opts) => {
|
|
154
|
+
let forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
|
|
155
|
+
return forwardedProto || getRequestUrl().protocol.replace(/:$/, "") || "http";
|
|
156
|
+
}
|
|
157
|
+
), setResponseHeaders = createNamedMock("setResponseHeaders", (headers) => {
|
|
158
|
+
getState().responseHeaders = new Headers(headers);
|
|
159
|
+
}), getResponseHeaders = createNamedMock(
|
|
160
|
+
"getResponseHeaders",
|
|
161
|
+
() => getState().responseHeaders
|
|
162
|
+
), getResponseHeader = createNamedMock("getResponseHeader", (name) => getState().responseHeaders.get(name) ?? void 0), setResponseHeader = createNamedMock(
|
|
163
|
+
"setResponseHeader",
|
|
164
|
+
(name, value) => {
|
|
165
|
+
let headers = getState().responseHeaders;
|
|
166
|
+
if (headers.delete(name), Array.isArray(value)) {
|
|
167
|
+
value.forEach((entry) => headers.append(name, entry));
|
|
168
|
+
return;
|
|
169
|
+
}
|
|
170
|
+
headers.set(name, value);
|
|
171
|
+
}
|
|
172
|
+
), removeResponseHeader = createNamedMock("removeResponseHeader", (name) => {
|
|
173
|
+
getState().responseHeaders.delete(name);
|
|
174
|
+
}), clearResponseHeaders = createNamedMock(
|
|
175
|
+
"clearResponseHeaders",
|
|
176
|
+
(headerNames) => {
|
|
177
|
+
if (!headerNames?.length) {
|
|
178
|
+
getState().responseHeaders = new Headers();
|
|
179
|
+
return;
|
|
180
|
+
}
|
|
181
|
+
headerNames.forEach((name) => getState().responseHeaders.delete(name));
|
|
182
|
+
}
|
|
183
|
+
), getResponseStatus = createNamedMock("getResponseStatus", () => getState().responseStatus?.code ?? 200), setResponseStatus = createNamedMock(
|
|
184
|
+
"setResponseStatus",
|
|
185
|
+
(code, text) => {
|
|
186
|
+
getState().responseStatus = {
|
|
187
|
+
code,
|
|
188
|
+
text
|
|
189
|
+
};
|
|
190
|
+
}
|
|
191
|
+
), getCookies = createNamedMock("getCookies", () => Object.fromEntries(getState().cookies)), getCookie = createNamedMock("getCookie", (name) => getState().cookies.get(name)), setCookie = createNamedMock(
|
|
192
|
+
"setCookie",
|
|
193
|
+
(name, value, options) => {
|
|
194
|
+
let state = getState();
|
|
195
|
+
state.cookies.set(name, value), state.responseHeaders.append("set-cookie", serializeCookie(name, value, options));
|
|
196
|
+
}
|
|
197
|
+
), deleteCookie = createNamedMock(
|
|
198
|
+
"deleteCookie",
|
|
199
|
+
(name, options) => {
|
|
200
|
+
let state = getState();
|
|
201
|
+
state.cookies.delete(name), state.responseHeaders.append(
|
|
202
|
+
"set-cookie",
|
|
203
|
+
serializeCookie(name, "", {
|
|
204
|
+
...options,
|
|
205
|
+
maxAge: 0
|
|
206
|
+
})
|
|
207
|
+
);
|
|
208
|
+
}
|
|
209
|
+
), useSession = createNamedMock(
|
|
210
|
+
"useSession",
|
|
211
|
+
async (_config) => getSessionRecord()
|
|
212
|
+
), getSession = createNamedMock(
|
|
213
|
+
"getSession",
|
|
214
|
+
async (_config) => getSessionRecord()
|
|
215
|
+
), updateSession = createNamedMock(
|
|
216
|
+
"updateSession",
|
|
217
|
+
async (_config, update) => getSessionRecord().update(update)
|
|
218
|
+
), sealSession = createNamedMock("sealSession", async (_config) => JSON.stringify(getState().sessionData)), unsealSession = createNamedMock(
|
|
219
|
+
"unsealSession",
|
|
220
|
+
async (_config, sealed) => {
|
|
221
|
+
try {
|
|
222
|
+
return JSON.parse(sealed);
|
|
223
|
+
} catch {
|
|
224
|
+
return {};
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
), clearSession = createNamedMock(
|
|
228
|
+
"clearSession",
|
|
229
|
+
async (_config) => {
|
|
230
|
+
getState().sessionData = {};
|
|
231
|
+
}
|
|
232
|
+
), getResponse = createNamedMock("getResponse", () => ({
|
|
233
|
+
status: getState().responseStatus?.code,
|
|
234
|
+
statusText: getState().responseStatus?.text,
|
|
235
|
+
get headers() {
|
|
236
|
+
return getState().responseHeaders;
|
|
237
|
+
}
|
|
238
|
+
})), getValidatedQuery = createNamedMock(
|
|
239
|
+
"getValidatedQuery",
|
|
240
|
+
async (schema) => {
|
|
241
|
+
let query = Object.fromEntries(getRequestUrl().searchParams.entries());
|
|
242
|
+
if (typeof schema?.parse == "function")
|
|
243
|
+
return schema.parse(query);
|
|
244
|
+
if (typeof schema?.safeParse == "function") {
|
|
245
|
+
let result = await schema.safeParse(query);
|
|
246
|
+
return result && typeof result == "object" && "data" in result ? result.data : result;
|
|
247
|
+
}
|
|
248
|
+
return typeof schema?.["~standard"]?.validate == "function" ? schema["~standard"].validate(query) : query;
|
|
249
|
+
}
|
|
250
|
+
);
|
|
251
|
+
export {
|
|
252
|
+
HEADERS,
|
|
253
|
+
StartServer,
|
|
254
|
+
VIRTUAL_MODULES,
|
|
255
|
+
attachRouterServerSsrUtils,
|
|
256
|
+
clearResponseHeaders,
|
|
257
|
+
clearSession,
|
|
258
|
+
createRequestHandler,
|
|
259
|
+
createStartHandler,
|
|
260
|
+
defaultRenderHandler,
|
|
261
|
+
defaultStreamHandler,
|
|
262
|
+
defineHandlerCallback,
|
|
263
|
+
deleteCookie,
|
|
264
|
+
getCookie,
|
|
265
|
+
getCookies,
|
|
266
|
+
getRequest,
|
|
267
|
+
getRequestHeader,
|
|
268
|
+
getRequestHeaders,
|
|
269
|
+
getRequestHost,
|
|
270
|
+
getRequestIP,
|
|
271
|
+
getRequestProtocol,
|
|
272
|
+
getRequestUrl,
|
|
273
|
+
getResponse,
|
|
274
|
+
getResponseHeader,
|
|
275
|
+
getResponseHeaders,
|
|
276
|
+
getResponseStatus,
|
|
277
|
+
getSession,
|
|
278
|
+
getValidatedQuery,
|
|
279
|
+
removeResponseHeader,
|
|
280
|
+
requestHandler,
|
|
281
|
+
sealSession,
|
|
282
|
+
setCookie,
|
|
283
|
+
setResponseHeader,
|
|
284
|
+
setResponseHeaders,
|
|
285
|
+
setResponseStatus,
|
|
286
|
+
transformPipeableStreamWithRouter,
|
|
287
|
+
transformReadableStreamWithRouter,
|
|
288
|
+
unsealSession,
|
|
289
|
+
updateSession,
|
|
290
|
+
useSession
|
|
291
|
+
};
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { Awaitable, RegisteredRouter } from '@tanstack/router-core';
|
|
2
|
+
|
|
3
|
+
interface StartStorageContext {
|
|
4
|
+
getRouter: () => Awaitable<RegisteredRouter>;
|
|
5
|
+
request: Request;
|
|
6
|
+
startOptions: any;
|
|
7
|
+
contextAfterGlobalMiddlewares: any;
|
|
8
|
+
executedRequestMiddlewares: Set<any>;
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
declare function runWithStartContext<T>(context: StartStorageContext, fn: () => T | Promise<T>): Promise<T>;
|
|
12
|
+
declare function getStartContext<TThrow extends boolean = true>(opts?: {
|
|
13
|
+
throwIfNotFound?: TThrow;
|
|
14
|
+
}): TThrow extends false ? StartStorageContext | undefined : StartStorageContext;
|
|
15
|
+
|
|
16
|
+
export { type StartStorageContext, getStartContext, runWithStartContext };
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import "../_browser-chunks/chunk-4BE7D4DS.js";
|
|
2
|
+
|
|
3
|
+
// src/export-mocks/start-storage-context.ts
|
|
4
|
+
var START_CONTEXT_SYMBOL = Symbol.for("storybook.tanstack-react.start-storage-context"), browserGlobals = globalThis;
|
|
5
|
+
function createFallbackStartContext() {
|
|
6
|
+
if (!(browserGlobals.__TSR_ROUTER__ === void 0 && browserGlobals.__TSS_START_OPTIONS__ === void 0))
|
|
7
|
+
return {
|
|
8
|
+
getRouter: () => browserGlobals.__TSR_ROUTER__,
|
|
9
|
+
request: new Request("http://localhost/"),
|
|
10
|
+
startOptions: browserGlobals.__TSS_START_OPTIONS__,
|
|
11
|
+
contextAfterGlobalMiddlewares: void 0,
|
|
12
|
+
executedRequestMiddlewares: /* @__PURE__ */ new Set()
|
|
13
|
+
};
|
|
14
|
+
}
|
|
15
|
+
async function runWithStartContext(context, fn) {
|
|
16
|
+
let previousContext = browserGlobals[START_CONTEXT_SYMBOL];
|
|
17
|
+
browserGlobals[START_CONTEXT_SYMBOL] = context;
|
|
18
|
+
try {
|
|
19
|
+
return await fn();
|
|
20
|
+
} finally {
|
|
21
|
+
previousContext ? browserGlobals[START_CONTEXT_SYMBOL] = previousContext : delete browserGlobals[START_CONTEXT_SYMBOL];
|
|
22
|
+
}
|
|
23
|
+
}
|
|
24
|
+
function getStartContext(opts) {
|
|
25
|
+
let context = browserGlobals[START_CONTEXT_SYMBOL] ?? createFallbackStartContext();
|
|
26
|
+
if (!context && opts?.throwIfNotFound !== !1)
|
|
27
|
+
throw new Error("No Start context found in Storybook mock.");
|
|
28
|
+
return context;
|
|
29
|
+
}
|
|
30
|
+
export {
|
|
31
|
+
getStartContext,
|
|
32
|
+
runWithStartContext
|
|
33
|
+
};
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
import React from 'react';
|
|
2
2
|
import { createServerFn as createServerFn$1 } from '@tanstack/start-client-core';
|
|
3
|
+
export * from '@tanstack/start-client-core';
|
|
4
|
+
export * from '@tanstack/react-start';
|
|
3
5
|
|
|
4
6
|
declare function useServerFn<T extends (...args: Array<any>) => Promise<any>>(serverFn: T): (...args: Parameters<T>) => ReturnType<T>;
|
|
5
7
|
declare const createServerFn: typeof createServerFn$1;
|
|
@@ -14,5 +16,15 @@ declare const Navigate: ({ to }: {
|
|
|
14
16
|
to: string;
|
|
15
17
|
}) => null;
|
|
16
18
|
declare const notFound: () => never;
|
|
19
|
+
declare const createStart: () => {};
|
|
20
|
+
declare const setCookie: (name: string, value: string) => void;
|
|
21
|
+
declare const getCookie: (name: string) => string | undefined;
|
|
22
|
+
declare const deleteCookie: (name: string) => void;
|
|
23
|
+
declare const clearCookieStore: () => void;
|
|
24
|
+
declare const fetchHandler: () => Promise<Response>;
|
|
17
25
|
|
|
18
|
-
|
|
26
|
+
declare const _default: {
|
|
27
|
+
fetch: () => Promise<Response>;
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
export { Link, Navigate, clearCookieStore, createServerFn, createStart, _default as default, deleteCookie, fetchHandler as fetch, getCookie, notFound, setCookie, useServerFn };
|
|
@@ -6,6 +6,8 @@ import "../_browser-chunks/chunk-4BE7D4DS.js";
|
|
|
6
6
|
// src/export-mocks/start.ts
|
|
7
7
|
import React from "react";
|
|
8
8
|
import { fn } from "storybook/test";
|
|
9
|
+
export * from "@tanstack/start-client-core";
|
|
10
|
+
export * from "@tanstack/react-start";
|
|
9
11
|
function useServerFn(serverFn) {
|
|
10
12
|
return React.useCallback(
|
|
11
13
|
(...args) => serverFn(...args),
|
|
@@ -27,11 +29,25 @@ var createServerFn = () => createMockServerFnBuilder(), Link = ({
|
|
|
27
29
|
onNavigate({ to });
|
|
28
30
|
}, [to]), null), notFound = () => {
|
|
29
31
|
throw new Error("Not found");
|
|
30
|
-
}
|
|
32
|
+
}, createStart = () => ({}), cookieStore = /* @__PURE__ */ new Map(), setCookie = (name, value) => {
|
|
33
|
+
cookieStore.set(name, value);
|
|
34
|
+
}, getCookie = (name) => cookieStore.get(name), deleteCookie = (name) => {
|
|
35
|
+
cookieStore.delete(name);
|
|
36
|
+
}, clearCookieStore = () => {
|
|
37
|
+
cookieStore.clear();
|
|
38
|
+
}, fetchHandler = async () => new Response("Storybook Mock", { status: 200 });
|
|
39
|
+
var start_default = { fetch: fetchHandler };
|
|
31
40
|
export {
|
|
32
41
|
Link,
|
|
33
42
|
Navigate,
|
|
43
|
+
clearCookieStore,
|
|
34
44
|
createServerFn,
|
|
45
|
+
createStart,
|
|
46
|
+
start_default as default,
|
|
47
|
+
deleteCookie,
|
|
48
|
+
fetchHandler as fetch,
|
|
49
|
+
getCookie,
|
|
35
50
|
notFound,
|
|
51
|
+
setCookie,
|
|
36
52
|
useServerFn
|
|
37
53
|
};
|
package/dist/index.d.ts
CHANGED
|
@@ -287,12 +287,38 @@ type CreateStoryRouteOptions<TRoute = undefined> = StoryRouteFileOptions<TRoute>
|
|
|
287
287
|
};
|
|
288
288
|
type StoryRouteOptions<TRoute = undefined> = CreateStoryRouteOptions<TRoute> | AnyRoute;
|
|
289
289
|
/**
|
|
290
|
-
*
|
|
291
|
-
*
|
|
290
|
+
* Per-route override options for use inside `RouteTreeOverrides`.
|
|
291
|
+
* Users can override `loader`, `beforeLoad`, etc. for a specific route.
|
|
292
292
|
*/
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
293
|
+
interface RouteOverrideOptions {
|
|
294
|
+
/** Override the route's loader function. */
|
|
295
|
+
loader?: (() => unknown) | (() => Promise<unknown>);
|
|
296
|
+
/** Override the route's beforeLoad function. */
|
|
297
|
+
beforeLoad?: (() => void) | (() => Promise<void>) | (() => Record<string, unknown>);
|
|
298
|
+
/** Override the route's search params validation. */
|
|
299
|
+
validateSearch?: (input: Record<string, unknown>) => Record<string, unknown>;
|
|
300
|
+
/** Override the route's loader dependencies. */
|
|
301
|
+
loaderDeps?: (opts: {
|
|
302
|
+
search: Record<string, unknown>;
|
|
303
|
+
}) => Record<string, unknown>;
|
|
304
|
+
/** Override the route's context function. */
|
|
305
|
+
context?: (() => Record<string, unknown>) | Record<string, unknown>;
|
|
306
|
+
}
|
|
307
|
+
/**
|
|
308
|
+
* A map of route overrides keyed by route ID.
|
|
309
|
+
* Each entry can override `loader`, `beforeLoad`, etc. for that route.
|
|
310
|
+
*
|
|
311
|
+
* @example
|
|
312
|
+
* ```ts
|
|
313
|
+
* routeOverrides: {
|
|
314
|
+
* '/_authed': { beforeLoad: () => {} },
|
|
315
|
+
* '/demo/form/simple/$id': {
|
|
316
|
+
* loader: async () => ({ name: 'Mock User' }),
|
|
317
|
+
* },
|
|
318
|
+
* }
|
|
319
|
+
* ```
|
|
320
|
+
*/
|
|
321
|
+
type RouteTreeOverrides = Record<keyof FileRoutesByPath, RouteOverrideOptions>;
|
|
296
322
|
interface RouterParameters<TRoute = undefined> {
|
|
297
323
|
/** A route object or route options to use for this story. */
|
|
298
324
|
route?: StoryRouteOptions<TRoute>;
|
|
@@ -302,16 +328,23 @@ interface RouterParameters<TRoute = undefined> {
|
|
|
302
328
|
params?: StoryRouteParams<TRoute>;
|
|
303
329
|
/** Search/query params to append to the URL (e.g. `{ tab: 'details' }`). */
|
|
304
330
|
query?: Partial<StoryRouteSearch<TRoute>>;
|
|
305
|
-
/**
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
331
|
+
/**
|
|
332
|
+
* Override options for specific routes in the app route tree (route tree mode only).
|
|
333
|
+
*
|
|
334
|
+
* Each key is a route ID (e.g. `'/about'`, `'__root__'`, `'/demo/form/simple/$id'`).
|
|
335
|
+
* Values can override `loader`, `beforeLoad`, etc. for that route.
|
|
336
|
+
*
|
|
337
|
+
* @example
|
|
338
|
+
* ```ts
|
|
339
|
+
* routeOverrides: {
|
|
340
|
+
* '/_authed': { beforeLoad: () => {} },
|
|
341
|
+
* '/demo/form/simple/$id': {
|
|
342
|
+
* loader: async () => ({ name: 'Mock User' }),
|
|
343
|
+
* },
|
|
344
|
+
* }
|
|
345
|
+
* ```
|
|
346
|
+
*/
|
|
347
|
+
routeOverrides?: RouteTreeOverrides;
|
|
315
348
|
}
|
|
316
349
|
|
|
317
350
|
type FrameworkName = CompatibleString<'@storybook/tanstack-react'>;
|
|
@@ -363,9 +396,7 @@ declare function definePreview<TRoute extends AnyRoute | undefined = undefined,
|
|
|
363
396
|
* Route object directly and TanStack parameters (params, query, loader, etc.)
|
|
364
397
|
* are inferred from the route's types.
|
|
365
398
|
*/
|
|
366
|
-
type Meta<TCmpOrArgs = Args> = IsRoute<TCmpOrArgs> extends true ? Omit<ComponentAnnotations<ReactRenderer, Args>, 'component'> & Partial<TanStackTypes<TCmpOrArgs>>
|
|
367
|
-
component?: TCmpOrArgs;
|
|
368
|
-
} : Meta$1<TCmpOrArgs>;
|
|
399
|
+
type Meta<TCmpOrArgs = Args> = IsRoute<TCmpOrArgs> extends true ? Omit<ComponentAnnotations<ReactRenderer, Args>, 'component'> & Partial<TanStackTypes<TCmpOrArgs>> : Meta$1<TCmpOrArgs>;
|
|
369
400
|
/**
|
|
370
401
|
* When the meta's `component` is a TanStack Route, the story inherits
|
|
371
402
|
* TanStack parameter types for type-safe params/query/loader configuration.
|
package/dist/index.js
CHANGED
package/dist/node/index.js
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
|
-
import
|
|
2
|
-
import
|
|
3
|
-
import
|
|
1
|
+
import CJS_COMPAT_NODE_URL_v7smzxhmon from 'node:url';
|
|
2
|
+
import CJS_COMPAT_NODE_PATH_v7smzxhmon from 'node:path';
|
|
3
|
+
import CJS_COMPAT_NODE_MODULE_v7smzxhmon from "node:module";
|
|
4
4
|
|
|
5
|
-
var __filename =
|
|
6
|
-
var __dirname =
|
|
7
|
-
var require =
|
|
5
|
+
var __filename = CJS_COMPAT_NODE_URL_v7smzxhmon.fileURLToPath(import.meta.url);
|
|
6
|
+
var __dirname = CJS_COMPAT_NODE_PATH_v7smzxhmon.dirname(__filename);
|
|
7
|
+
var require = CJS_COMPAT_NODE_MODULE_v7smzxhmon.createRequire(import.meta.url);
|
|
8
8
|
|
|
9
9
|
// ------------------------------------------------------------
|
|
10
10
|
// end of CJS compatibility banner, injected by Storybook's esbuild configuration
|
package/dist/preset.js
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
|
-
import
|
|
2
|
-
import
|
|
3
|
-
import
|
|
1
|
+
import CJS_COMPAT_NODE_URL_v7smzxhmon from 'node:url';
|
|
2
|
+
import CJS_COMPAT_NODE_PATH_v7smzxhmon from 'node:path';
|
|
3
|
+
import CJS_COMPAT_NODE_MODULE_v7smzxhmon from "node:module";
|
|
4
4
|
|
|
5
|
-
var __filename =
|
|
6
|
-
var __dirname =
|
|
7
|
-
var require =
|
|
5
|
+
var __filename = CJS_COMPAT_NODE_URL_v7smzxhmon.fileURLToPath(import.meta.url);
|
|
6
|
+
var __dirname = CJS_COMPAT_NODE_PATH_v7smzxhmon.dirname(__filename);
|
|
7
|
+
var require = CJS_COMPAT_NODE_MODULE_v7smzxhmon.createRequire(import.meta.url);
|
|
8
8
|
|
|
9
9
|
// ------------------------------------------------------------
|
|
10
10
|
// end of CJS compatibility banner, injected by Storybook's esbuild configuration
|
|
@@ -13,7 +13,193 @@ var require = CJS_COMPAT_NODE_MODULE_oxmslr6vq0s.createRequire(import.meta.url);
|
|
|
13
13
|
// src/preset.ts
|
|
14
14
|
import { fileURLToPath } from "node:url";
|
|
15
15
|
import { viteFinal as reactViteFinal } from "@storybook/react-vite/preset";
|
|
16
|
-
|
|
16
|
+
|
|
17
|
+
// src/plugins/server-code-elimination.ts
|
|
18
|
+
import { transformSync } from "@babel/core";
|
|
19
|
+
import {
|
|
20
|
+
isImportDeclaration,
|
|
21
|
+
isIdentifier,
|
|
22
|
+
isImportSpecifier,
|
|
23
|
+
isMemberExpression,
|
|
24
|
+
isCallExpression,
|
|
25
|
+
isExpression,
|
|
26
|
+
identifier,
|
|
27
|
+
stringLiteral,
|
|
28
|
+
callExpression,
|
|
29
|
+
importDeclaration,
|
|
30
|
+
importSpecifier
|
|
31
|
+
} from "@babel/types";
|
|
32
|
+
var SERVER_FN_RE = /\bcreateServerFn\b/, MIDDLEWARE_RE = /\bcreateMiddleware\b/, ISOMORPHIC_FN_RE = /\bcreateIsomorphicFn\b/, SERVER_ONLY_FN_RE = /\bcreateServerOnlyFn\b/, CLIENT_ONLY_FN_RE = /\bcreateClientOnlyFn\b/, ANY_PATTERN_RE = /\b(createServerFn|createMiddleware|createIsomorphicFn|createServerOnlyFn|createClientOnlyFn)\b/;
|
|
33
|
+
function serverCodeEliminationPlugin() {
|
|
34
|
+
return {
|
|
35
|
+
name: "storybook:tanstack-react:server-code-elimination",
|
|
36
|
+
enforce: "pre",
|
|
37
|
+
transform: {
|
|
38
|
+
// we can fully rely on transform.filter
|
|
39
|
+
// and not worry about the handler since tanstack start users are Vite > 8 only
|
|
40
|
+
filter: {
|
|
41
|
+
id: {
|
|
42
|
+
include: [/\.tsx?$/],
|
|
43
|
+
// todo make export-mocks more robust (currently we just exclude all files in that folder, but ideally we should only exclude the relevant ones)
|
|
44
|
+
exclude: [/node_modules/, /export-mocks/]
|
|
45
|
+
},
|
|
46
|
+
code: ANY_PATTERN_RE
|
|
47
|
+
},
|
|
48
|
+
async handler(code, id) {
|
|
49
|
+
if (!/\.[mc]?[jt]sx?$/.test(id) || !ANY_PATTERN_RE.test(code))
|
|
50
|
+
return null;
|
|
51
|
+
let state = { code, modified: !1, needsFnImport: !1 }, result = transformSync(code, {
|
|
52
|
+
filename: id,
|
|
53
|
+
sourceType: "module",
|
|
54
|
+
parserOpts: {
|
|
55
|
+
plugins: ["typescript", "jsx"]
|
|
56
|
+
},
|
|
57
|
+
plugins: [() => serverCodeElimination(state)],
|
|
58
|
+
sourceMaps: !0,
|
|
59
|
+
configFile: !1,
|
|
60
|
+
babelrc: !1
|
|
61
|
+
});
|
|
62
|
+
return !state.modified || !result?.code ? null : {
|
|
63
|
+
code: result.code,
|
|
64
|
+
map: result.map
|
|
65
|
+
};
|
|
66
|
+
}
|
|
67
|
+
}
|
|
68
|
+
};
|
|
69
|
+
}
|
|
70
|
+
function serverCodeElimination(state) {
|
|
71
|
+
function sbFnCall() {
|
|
72
|
+
return state.needsFnImport = !0, buildFnCall();
|
|
73
|
+
}
|
|
74
|
+
function sbFnCallWithImpl(impl) {
|
|
75
|
+
return state.needsFnImport = !0, buildFnCallWithImpl(impl);
|
|
76
|
+
}
|
|
77
|
+
return {
|
|
78
|
+
visitor: {
|
|
79
|
+
Program(programPath) {
|
|
80
|
+
let tanstackImports = collectTanstackImports(programPath.node.body), resolves = (name, factory) => resolvesToFactory(tanstackImports, name, factory);
|
|
81
|
+
programPath.traverse({
|
|
82
|
+
CallExpression(path) {
|
|
83
|
+
let node = path.node;
|
|
84
|
+
if (isIdentifier(node.callee) && resolves(node.callee.name, "createServerOnlyFn") && SERVER_ONLY_FN_RE.test(state.code)) {
|
|
85
|
+
path.replaceWith(sbFnCall()), state.modified = !0;
|
|
86
|
+
return;
|
|
87
|
+
}
|
|
88
|
+
if (isIdentifier(node.callee) && resolves(node.callee.name, "createClientOnlyFn") && CLIENT_ONLY_FN_RE.test(state.code)) {
|
|
89
|
+
let innerFn = node.arguments[0];
|
|
90
|
+
innerFn && isExpression(innerFn) && (path.replaceWith(sbFnCallWithImpl(innerFn)), state.modified = !0);
|
|
91
|
+
return;
|
|
92
|
+
}
|
|
93
|
+
let methodName = getMethodName(node);
|
|
94
|
+
if (!methodName)
|
|
95
|
+
return;
|
|
96
|
+
let root = findChainRoot(node);
|
|
97
|
+
if (root) {
|
|
98
|
+
if (methodName === "handler" && resolves(root.rootName, "createServerFn") && SERVER_FN_RE.test(state.code)) {
|
|
99
|
+
let handlerArg = node.arguments[0];
|
|
100
|
+
if (handlerArg) {
|
|
101
|
+
if (isIdentifier(handlerArg)) {
|
|
102
|
+
let binding = path.scope.getBinding(handlerArg.name);
|
|
103
|
+
binding && binding.path.remove();
|
|
104
|
+
}
|
|
105
|
+
node.arguments[0] = sbFnCall();
|
|
106
|
+
}
|
|
107
|
+
state.modified = !0;
|
|
108
|
+
return;
|
|
109
|
+
}
|
|
110
|
+
if (resolves(root.rootName, "createMiddleware") && MIDDLEWARE_RE.test(state.code)) {
|
|
111
|
+
(methodName === "server" || methodName === "inputValidator") && isMemberExpression(path.node.callee) && (path.replaceWith(path.node.callee.object), state.modified = !0);
|
|
112
|
+
return;
|
|
113
|
+
}
|
|
114
|
+
if (resolves(root.rootName, "createIsomorphicFn") && ISOMORPHIC_FN_RE.test(state.code)) {
|
|
115
|
+
if (methodName === "client") {
|
|
116
|
+
let innerFn = node.arguments[0];
|
|
117
|
+
innerFn && isExpression(innerFn) && (path.replaceWith(sbFnCallWithImpl(innerFn)), state.modified = !0);
|
|
118
|
+
return;
|
|
119
|
+
}
|
|
120
|
+
if (methodName === "server") {
|
|
121
|
+
let parent = path.parent;
|
|
122
|
+
(!isMemberExpression(parent) || !isCallExpression(path.parentPath?.parent)) && (path.replaceWith(sbFnCall()), state.modified = !0);
|
|
123
|
+
}
|
|
124
|
+
return;
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
}), state.modified && (state.needsFnImport && programPath.node.body.unshift(buildFnImport()), eliminateDeadImports(programPath));
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
function buildFnImport() {
|
|
134
|
+
return importDeclaration(
|
|
135
|
+
[importSpecifier(identifier("__sb_fn"), identifier("fn"))],
|
|
136
|
+
stringLiteral("storybook/test")
|
|
137
|
+
);
|
|
138
|
+
}
|
|
139
|
+
function buildFnCall() {
|
|
140
|
+
return callExpression(identifier("__sb_fn"), []);
|
|
141
|
+
}
|
|
142
|
+
function buildFnCallWithImpl(impl) {
|
|
143
|
+
return callExpression(identifier("__sb_fn"), [impl]);
|
|
144
|
+
}
|
|
145
|
+
function collectTanstackImports(body) {
|
|
146
|
+
let imports = /* @__PURE__ */ new Map();
|
|
147
|
+
for (let node of body) {
|
|
148
|
+
if (!isImportDeclaration(node))
|
|
149
|
+
continue;
|
|
150
|
+
let src = node.source.value;
|
|
151
|
+
if (!(!src.includes("@tanstack/") && !src.includes("export-mocks") && !src.includes("@storybook/tanstack-react"))) {
|
|
152
|
+
for (let spec of node.specifiers)
|
|
153
|
+
if (isImportSpecifier(spec)) {
|
|
154
|
+
let importedName = isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
|
|
155
|
+
imports.set(spec.local.name, importedName);
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
return imports;
|
|
160
|
+
}
|
|
161
|
+
function resolvesToFactory(imports, name, factoryName) {
|
|
162
|
+
return name === factoryName || imports.get(name) === factoryName;
|
|
163
|
+
}
|
|
164
|
+
function findChainRoot(node) {
|
|
165
|
+
let current = node;
|
|
166
|
+
for (; ; ) {
|
|
167
|
+
let callee = current.callee;
|
|
168
|
+
if (isIdentifier(callee))
|
|
169
|
+
return { rootCall: current, rootName: callee.name };
|
|
170
|
+
if (isMemberExpression(callee) && isCallExpression(callee.object)) {
|
|
171
|
+
current = callee.object;
|
|
172
|
+
continue;
|
|
173
|
+
}
|
|
174
|
+
return null;
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
function getMethodName(node) {
|
|
178
|
+
return isMemberExpression(node.callee) && isIdentifier(node.callee.property) ? node.callee.property.name : null;
|
|
179
|
+
}
|
|
180
|
+
function eliminateDeadImports(programPath) {
|
|
181
|
+
let referencedIdentifiers = /* @__PURE__ */ new Set();
|
|
182
|
+
programPath.traverse({
|
|
183
|
+
enter(path) {
|
|
184
|
+
let { node } = path;
|
|
185
|
+
isIdentifier(node) && !path.isBindingIdentifier() && referencedIdentifiers.add(node.name);
|
|
186
|
+
}
|
|
187
|
+
}), programPath.traverse({
|
|
188
|
+
ImportDeclaration(path) {
|
|
189
|
+
let specifiers = path.node.specifiers.filter(
|
|
190
|
+
(spec) => referencedIdentifiers.has(spec.local.name)
|
|
191
|
+
);
|
|
192
|
+
specifiers.length === 0 ? path.remove() : specifiers.length !== path.node.specifiers.length && (path.node.specifiers = specifiers);
|
|
193
|
+
}
|
|
194
|
+
});
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
// src/preset.ts
|
|
198
|
+
var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"], INTERCEPTED_MODULES = ["@tanstack/react-start"], START_SERVER_MODULES = [
|
|
199
|
+
"@tanstack/react-start/server",
|
|
200
|
+
"@tanstack/react-start-server",
|
|
201
|
+
"@tanstack/start-server-core"
|
|
202
|
+
], core = async (config, options) => {
|
|
17
203
|
let framework = await options.presets.apply("framework");
|
|
18
204
|
return {
|
|
19
205
|
...config,
|
|
@@ -32,10 +218,13 @@ var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"
|
|
|
32
218
|
return p.some(isTanStackStartPlugin);
|
|
33
219
|
let pluginRecord = p;
|
|
34
220
|
return typeof p == "object" && p !== null && "name" in pluginRecord && typeof pluginRecord.name == "string" && (pluginRecord.name.startsWith("tanstack-start") || pluginRecord.name.includes("rsc:"));
|
|
35
|
-
}, stubPath = fileURLToPath(import.meta.resolve("./export-mocks/start.js")),
|
|
221
|
+
}, stubPath = fileURLToPath(import.meta.resolve("./export-mocks/start.js")), startServerMockPath = fileURLToPath(import.meta.resolve("./export-mocks/start-server.js")), startStorageContextMockPath = fileURLToPath(
|
|
222
|
+
import.meta.resolve("./export-mocks/start-storage-context.js")
|
|
223
|
+
), routerMockPath = fileURLToPath(
|
|
36
224
|
import.meta.resolve("@storybook/tanstack-react/react-router")
|
|
37
225
|
), plugins = [
|
|
38
226
|
...(reactConfig.plugins ?? []).filter((p) => !isTanStackStartPlugin(p)),
|
|
227
|
+
serverCodeEliminationPlugin(),
|
|
39
228
|
{
|
|
40
229
|
name: "tanstack-start-plugin-remover",
|
|
41
230
|
enforce: "pre",
|
|
@@ -44,8 +233,12 @@ var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"
|
|
|
44
233
|
handler(id, importer) {
|
|
45
234
|
if ((id === "@tanstack/react-router" || id.startsWith("@tanstack/react-router/")) && importer && !importer.includes("export-mocks"))
|
|
46
235
|
return routerMockPath;
|
|
236
|
+
if (START_SERVER_MODULES.includes(id))
|
|
237
|
+
return startServerMockPath;
|
|
238
|
+
if (id === "@tanstack/start-storage-context")
|
|
239
|
+
return startStorageContextMockPath;
|
|
47
240
|
for (let mod of INTERCEPTED_MODULES)
|
|
48
|
-
if (id === mod
|
|
241
|
+
if (id === mod)
|
|
49
242
|
return stubPath;
|
|
50
243
|
for (let pattern of INTERCEPTED_PATTERNS)
|
|
51
244
|
if (id.includes(pattern))
|
|
@@ -56,7 +249,12 @@ var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"
|
|
|
56
249
|
config() {
|
|
57
250
|
return {
|
|
58
251
|
optimizeDeps: {
|
|
59
|
-
exclude: [
|
|
252
|
+
exclude: [
|
|
253
|
+
"@storybook/tanstack-react",
|
|
254
|
+
"@tanstack/react-start/server",
|
|
255
|
+
"@tanstack/react-start-server",
|
|
256
|
+
"@tanstack/start-server-core"
|
|
257
|
+
]
|
|
60
258
|
}
|
|
61
259
|
};
|
|
62
260
|
}
|
package/dist/preview.d.ts
CHANGED
|
@@ -26,12 +26,38 @@ type CreateStoryRouteOptions<TRoute = undefined> = StoryRouteFileOptions<TRoute>
|
|
|
26
26
|
};
|
|
27
27
|
type StoryRouteOptions<TRoute = undefined> = CreateStoryRouteOptions<TRoute> | AnyRoute;
|
|
28
28
|
/**
|
|
29
|
-
*
|
|
30
|
-
*
|
|
29
|
+
* Per-route override options for use inside `RouteTreeOverrides`.
|
|
30
|
+
* Users can override `loader`, `beforeLoad`, etc. for a specific route.
|
|
31
31
|
*/
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
32
|
+
interface RouteOverrideOptions {
|
|
33
|
+
/** Override the route's loader function. */
|
|
34
|
+
loader?: (() => unknown) | (() => Promise<unknown>);
|
|
35
|
+
/** Override the route's beforeLoad function. */
|
|
36
|
+
beforeLoad?: (() => void) | (() => Promise<void>) | (() => Record<string, unknown>);
|
|
37
|
+
/** Override the route's search params validation. */
|
|
38
|
+
validateSearch?: (input: Record<string, unknown>) => Record<string, unknown>;
|
|
39
|
+
/** Override the route's loader dependencies. */
|
|
40
|
+
loaderDeps?: (opts: {
|
|
41
|
+
search: Record<string, unknown>;
|
|
42
|
+
}) => Record<string, unknown>;
|
|
43
|
+
/** Override the route's context function. */
|
|
44
|
+
context?: (() => Record<string, unknown>) | Record<string, unknown>;
|
|
45
|
+
}
|
|
46
|
+
/**
|
|
47
|
+
* A map of route overrides keyed by route ID.
|
|
48
|
+
* Each entry can override `loader`, `beforeLoad`, etc. for that route.
|
|
49
|
+
*
|
|
50
|
+
* @example
|
|
51
|
+
* ```ts
|
|
52
|
+
* routeOverrides: {
|
|
53
|
+
* '/_authed': { beforeLoad: () => {} },
|
|
54
|
+
* '/demo/form/simple/$id': {
|
|
55
|
+
* loader: async () => ({ name: 'Mock User' }),
|
|
56
|
+
* },
|
|
57
|
+
* }
|
|
58
|
+
* ```
|
|
59
|
+
*/
|
|
60
|
+
type RouteTreeOverrides = Record<keyof FileRoutesByPath, RouteOverrideOptions>;
|
|
35
61
|
interface RouterParameters<TRoute = undefined> {
|
|
36
62
|
/** A route object or route options to use for this story. */
|
|
37
63
|
route?: StoryRouteOptions<TRoute>;
|
|
@@ -41,16 +67,23 @@ interface RouterParameters<TRoute = undefined> {
|
|
|
41
67
|
params?: StoryRouteParams<TRoute>;
|
|
42
68
|
/** Search/query params to append to the URL (e.g. `{ tab: 'details' }`). */
|
|
43
69
|
query?: Partial<StoryRouteSearch<TRoute>>;
|
|
44
|
-
/**
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
70
|
+
/**
|
|
71
|
+
* Override options for specific routes in the app route tree (route tree mode only).
|
|
72
|
+
*
|
|
73
|
+
* Each key is a route ID (e.g. `'/about'`, `'__root__'`, `'/demo/form/simple/$id'`).
|
|
74
|
+
* Values can override `loader`, `beforeLoad`, etc. for that route.
|
|
75
|
+
*
|
|
76
|
+
* @example
|
|
77
|
+
* ```ts
|
|
78
|
+
* routeOverrides: {
|
|
79
|
+
* '/_authed': { beforeLoad: () => {} },
|
|
80
|
+
* '/demo/form/simple/$id': {
|
|
81
|
+
* loader: async () => ({ name: 'Mock User' }),
|
|
82
|
+
* },
|
|
83
|
+
* }
|
|
84
|
+
* ```
|
|
85
|
+
*/
|
|
86
|
+
routeOverrides?: RouteTreeOverrides;
|
|
54
87
|
}
|
|
55
88
|
|
|
56
89
|
interface TanStackPreviewOptions<TRoute = undefined> {
|
package/dist/preview.js
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@storybook/tanstack-react",
|
|
3
|
-
"version": "0.0.0-pr-34403-sha-
|
|
3
|
+
"version": "0.0.0-pr-34403-sha-da307159",
|
|
4
4
|
"description": "Storybook for TanStack (React, Vite): Router + Query ready Storybook framework",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"storybook",
|
|
@@ -59,6 +59,16 @@
|
|
|
59
59
|
"types": "./dist/export-mocks/start.d.ts",
|
|
60
60
|
"code": "./src/export-mocks/start.ts",
|
|
61
61
|
"default": "./dist/export-mocks/start.js"
|
|
62
|
+
},
|
|
63
|
+
"./start-server": {
|
|
64
|
+
"types": "./dist/export-mocks/start-server.d.ts",
|
|
65
|
+
"code": "./src/export-mocks/start-server.ts",
|
|
66
|
+
"default": "./dist/export-mocks/start-server.js"
|
|
67
|
+
},
|
|
68
|
+
"./start-storage-context": {
|
|
69
|
+
"types": "./dist/export-mocks/start-storage-context.d.ts",
|
|
70
|
+
"code": "./src/export-mocks/start-storage-context.ts",
|
|
71
|
+
"default": "./dist/export-mocks/start-storage-context.js"
|
|
62
72
|
}
|
|
63
73
|
},
|
|
64
74
|
"files": [
|
|
@@ -70,9 +80,11 @@
|
|
|
70
80
|
"!src/**/*"
|
|
71
81
|
],
|
|
72
82
|
"dependencies": {
|
|
73
|
-
"@
|
|
74
|
-
"@
|
|
75
|
-
"@storybook/
|
|
83
|
+
"@babel/core": "7.29.0",
|
|
84
|
+
"@babel/types": "7.29.0",
|
|
85
|
+
"@storybook/builder-vite": "0.0.0-pr-34403-sha-da307159",
|
|
86
|
+
"@storybook/react": "0.0.0-pr-34403-sha-da307159",
|
|
87
|
+
"@storybook/react-vite": "0.0.0-pr-34403-sha-da307159"
|
|
76
88
|
},
|
|
77
89
|
"devDependencies": {
|
|
78
90
|
"@tanstack/react-router": "^1.168.10",
|
|
@@ -91,7 +103,7 @@
|
|
|
91
103
|
"@tanstack/start-client-core": "^1.167.9",
|
|
92
104
|
"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
|
|
93
105
|
"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
|
|
94
|
-
"storybook": "^0.0.0-pr-34403-sha-
|
|
106
|
+
"storybook": "^0.0.0-pr-34403-sha-da307159",
|
|
95
107
|
"vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
|
|
96
108
|
},
|
|
97
109
|
"peerDependenciesMeta": {
|