@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

package/dist/src/core/devVendorPaths.d.ts

@@ -0,0 +1,17 @@
+/** Module-level dev vendor paths state.
+ *  Set by devBuild() before the initial build so that build() can
+ *  externalize React and rewrite imports to stable vendor files.
+ *  Production builds never call setDevVendorPaths, so the getter
+ *  returns null and build() bundles React normally. */
+export declare const getDevVendorPaths: () => Record<string, string> | null;
+export declare const setDevVendorPaths: (paths: Record<string, string>) => void;
+export declare const getAngularVendorPaths: () => Record<string, string> | null;
+export declare const setAngularVendorPaths: (paths: Record<string, string>) => void;
+export declare const getAngularServerVendorPaths: () => Record<string, string> | null;
+export declare const setAngularServerVendorPaths: (paths: Record<string, string>) => void;
+export declare const getSvelteVendorPaths: () => Record<string, string> | null;
+export declare const setSvelteVendorPaths: (paths: Record<string, string>) => void;
+export declare const getVueVendorPaths: () => Record<string, string> | null;
+export declare const setVueVendorPaths: (paths: Record<string, string>) => void;
+export declare const getEmberVendorPaths: () => Record<string, string> | null;
+export declare const setEmberVendorPaths: (paths: Record<string, string>) => void;

package/dist/src/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lookup';
+export * from './islands';
+export * from './pageHandlers';
+export * from './prepare';
+export * from './renderIslandMarkup';
+export * from './responseEnhancers';
+export * from './wrapPageHandlerWithStreamingSlots';

package/dist/src/core/islandManifest.d.ts

@@ -0,0 +1,3 @@
+import type { IslandFramework } from '../../types/island';
+export declare const getIslandManifestEntries: (manifest: Record<string, string>) => Partial<Record<IslandFramework, Record<string, string>>>;
+export declare const getIslandManifestKey: (framework: IslandFramework, component: string) => string;

package/dist/src/core/islandMarkupAttributes.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeIslandRenderProps } from '../../types/island';
+type IslandMarkerAttributes = {
+    'data-component': string;
+    'data-framework': string;
+    'data-hydrate': string;
+    'data-island': 'true';
+    'data-island-id'?: string;
+    'data-props': string;
+};
+export declare const getIslandMarkerAttributes: (props: RuntimeIslandRenderProps, islandId?: string) => IslandMarkerAttributes;
+export declare const serializeIslandAttributes: (attributes: Record<string, string>) => string;
+export {};

package/dist/src/core/islandPageContext.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    var __absoluteManifest: Record<string, string> | undefined;
+    var __ABS_ISLAND_STATE__: Record<string, Record<string, unknown>> | undefined;
+}
+export declare const htmlContainsIslands: (html: string) => boolean;
+export declare const injectIslandPageContext: (html: string, options?: {
+    hasIslands?: boolean;
+}) => string;
+export declare const injectIslandPageContextStream: (stream: ReadableStream<string | Uint8Array>, options?: {
+    hasIslands?: boolean;
+}) => ReadableStream<string | Uint8Array<ArrayBufferLike>>;
+export declare const setCurrentIslandManifest: (manifest: Record<string, string>) => void;

package/dist/src/core/islandSsr.d.ts

@@ -0,0 +1,6 @@
+type ReactComponentType<Props extends Record<string, unknown>> = import('react').ComponentType<Props>;
+export declare const renderAngularIslandToHtml: (component: import("@angular/core").Type<object>, props: Record<string, unknown>, islandId: string) => Promise<string>;
+export declare const renderReactIslandToHtml: <Props extends Record<string, unknown>>(component: ReactComponentType<Props>, props: Props) => Promise<string>;
+export declare const renderSvelteIslandToHtml: <Props extends Record<string, unknown>>(component: import("svelte").Component<Props>, props: Props) => Promise<string>;
+export declare const renderVueIslandToHtml: <Props extends Record<string, unknown>>(component: import("vue").Component<Props>, props: Props) => Promise<string>;
+export {};

package/dist/src/core/islands.d.ts

@@ -0,0 +1,16 @@
+import type { IslandComponentDefinition, IslandRegistry, IslandRegistryInput } from '../../types/island';
+export declare const defineIslandComponent: <Component>(component: Component, options: {
+    export?: string;
+    source: string;
+}) => IslandComponentDefinition<Component>;
+export declare const defineIslandRegistry: <T extends IslandRegistryInput>(registry: IslandRegistry<T>) => T;
+export declare const getIslandBuildReference: <Component>(component: Component | IslandComponentDefinition<Component>) => {
+    export: string | undefined;
+    source: string;
+} | null;
+export declare const isIslandComponentDefinition: <Component>(value: Component | IslandComponentDefinition<Component>) => value is IslandComponentDefinition<Component>;
+export declare function getIslandComponent<Component>(component: Component): Component;
+export declare function getIslandComponent<Component>(component: IslandComponentDefinition<Component>): Component;
+export declare const parseIslandProps: (rawProps: string | null) => any;
+export declare const serializeIslandProps: (props: unknown) => string;
+export { getIslandManifestEntries, getIslandManifestKey } from './islandManifest';

package/dist/src/core/loadIslandRegistry.d.ts

@@ -0,0 +1 @@
+export declare const loadIslandRegistry: (registryPath: string) => Promise<Partial<Record<import("..").IslandFramework, Record<string, unknown>>>>;

package/dist/src/core/lookup.d.ts

@@ -0,0 +1 @@
+export declare const asset: (source: Record<string, string>, name: string) => string;

package/dist/src/core/normalizeIslandProps.d.ts

@@ -0,0 +1,15 @@
+import type { IslandFramework, IslandHydrate } from '../../types/island';
+type RawIslandProps = {
+    component: string;
+    framework: string;
+    hydrate?: string | undefined;
+    props: unknown;
+};
+export declare const normalizeRuntimeIslandRenderProps: (raw: RawIslandProps) => {
+    component: string;
+    framework: IslandFramework;
+    hydrate: IslandHydrate | undefined;
+    props: Record<string, unknown>;
+};
+export declare const normalizeIslandProps: (value: unknown) => Record<string, unknown>;
+export {};

package/dist/src/core/pageHandlers.d.ts

@@ -0,0 +1,5 @@
+import { type StreamingSlotEnhancerOptions } from './responseEnhancers';
+export type StaticPageRequestOptions = StreamingSlotEnhancerOptions;
+export type HTMLPageRequestOptions = StaticPageRequestOptions;
+export declare const handleHTMLPageRequest: (pagePath: string, options?: HTMLPageRequestOptions) => Promise<Response>;
+export declare const handleHTMXPageRequest: (pagePath: string) => Promise<Response>;

package/dist/src/core/prepare.d.ts

@@ -0,0 +1,417 @@
+import { Elysia } from 'elysia';
+export declare const prepare: (configOrPath?: string) => Promise<{
+    absolutejs: Elysia<"", {
+        decorator: {};
+        store: {};
+        derive: {};
+        resolve: {};
+    }, {
+        typebox: {};
+        error: {};
+    } & {
+        typebox: {};
+        error: {};
+    }, {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {
+            200: Response;
+        };
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {
+            200: Response;
+        };
+    }, (((({
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                };
+            };
+        };
+    } & {
+        ".well-known": {
+            appspecific: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }) | ({
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                };
+            };
+        };
+    } & {
+        ".well-known": {
+            appspecific: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {};
+            };
+        };
+    })) & {
+        "@src": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        "@stub": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        "@hmr": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        "@ng": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        hmr: {
+            subscribe: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        "hmr-status": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response | {
+                        connectedClients: number;
+                        isRebuilding: boolean;
+                        manifestKeys: string[];
+                        rebuildCount: number;
+                        rebuildQueue: string[];
+                        timestamp: number;
+                    };
+                };
+            };
+        };
+    }) & {}) & {}, {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }, {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }>;
+    manifest: Record<string, string>;
+} | {
+    absolutejs: Elysia<"", {
+        decorator: {};
+        store: {};
+        derive: {};
+        resolve: {};
+    }, {
+        typebox: {};
+        error: {};
+    } & {
+        typebox: {};
+        error: {};
+    }, {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {
+            200: Response;
+        };
+    }, {
+        ".absolutejs": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Bun.BunFile | "Not Found";
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {};
+            };
+        };
+    } & {
+        ".absolutejs": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Bun.BunFile | "Not Found";
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    }), {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }, {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    }>;
+    manifest: Record<string, string>;
+}>;

package/dist/src/core/prerender.d.ts

@@ -0,0 +1,31 @@
+import type { StaticConfig } from '../../types/build';
+export type PrerenderResult = {
+    /** Map of route path → rendered HTML file path on disk */
+    routes: Map<string, string>;
+    /** Directory where pre-rendered files are stored */
+    dir: string;
+};
+type LogFn = (message: string) => void;
+/** Header used to bypass the prerender cache during ISR re-renders */
+export declare const PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass";
+/** Convert a URL path to a filename: "/" → "index.html", "/vue" → "vue.html" */
+export declare const routeToFilename: (route: string) => string;
+/** Read the render timestamp for a pre-rendered page. Returns 0 if not found. */
+export declare const readTimestamp: (htmlPath: string) => number;
+/**
+ * Re-render a single route by fetching it from the running server
+ * with the bypass header so it hits SSR instead of the cache.
+ */
+export declare const rerenderRoute: (route: string, port: number, prerenderDir: string) => Promise<boolean>;
+/**
+ * Pre-render routes by fetching them from a running server and saving the HTML to disk.
+ *
+ * Used by both `absolute start` (SSG) and `absolute compile`.
+ */
+export declare const prerender: (port: number, outDir: string, staticConfig: StaticConfig, log?: LogFn) => Promise<PrerenderResult>;
+/**
+ * Start the bundled production server, wait for it to be ready, pre-render,
+ * then kill it.
+ */
+export declare const prerenderWithServer: (serverBundlePath: string, port: number, outDir: string, staticConfig: StaticConfig, env: Record<string, string>, log?: LogFn) => Promise<PrerenderResult>;
+export {};

package/dist/src/core/renderIslandMarkup.d.ts

@@ -0,0 +1,13 @@
+import type { IslandRegistry, IslandRegistryInput, RuntimeIslandRenderProps } from '../../types/island';
+export declare const renderIslandMarkup: <T extends IslandRegistryInput>(registry: IslandRegistry<T> | T, props: RuntimeIslandRenderProps) => Promise<string>;
+export declare const renderIslandResult: <T extends IslandRegistryInput>(registry: IslandRegistry<T> | T, props: RuntimeIslandRenderProps) => Promise<{
+    attributes: {
+        'data-component': string;
+        'data-framework': string;
+        'data-hydrate': string;
+        'data-island': "true";
+        'data-island-id'?: string;
+        'data-props': string;
+    };
+    html: string;
+}>;

package/dist/src/core/responseEnhancers.d.ts

@@ -0,0 +1,10 @@
+import { type AppendStreamingSlotsOptions, type StreamingSlotPolicy, type StreamingSlot } from '../utils/streamingSlots';
+type ResponseLike = Response | Promise<Response>;
+export type StreamingSlotEnhancerOptions = Omit<AppendStreamingSlotsOptions, 'injectRuntime'> & {
+    streamingSlots?: StreamingSlot[];
+    policy?: StreamingSlotPolicy;
+};
+export declare const enhanceHtmlResponseWithStreamingSlots: (response: Response, { nonce, onError, runtimePlacement, runtimePreludeScript, streamingSlots, policy }?: StreamingSlotEnhancerOptions) => Response;
+export declare const withStreamingSlots: (responseLike: ResponseLike, options?: StreamingSlotEnhancerOptions) => Promise<Response>;
+export declare const withRegisteredStreamingSlots: (renderResponse: () => ResponseLike, options?: StreamingSlotEnhancerOptions) => Promise<Response>;
+export {};

package/dist/src/core/staticStreaming.d.ts

@@ -0,0 +1,25 @@
+import type { StreamingSlotPatchPayload } from '../utils/streamingSlots';
+export type StaticStreamingSlotResolver = () => Promise<StreamingSlotPatchPayload> | StreamingSlotPatchPayload;
+export type StaticStreamingSlotDefinition = {
+    resolve: StaticStreamingSlotResolver;
+    timeoutMs?: number;
+    errorHtml?: string;
+};
+export type StaticStreamingSlotDefinitions = Record<string, StaticStreamingSlotResolver | StaticStreamingSlotDefinition>;
+export declare const defineStaticStreamingSlots: <const T extends StaticStreamingSlotDefinitions>(slots: T) => T;
+type StaticStreamingTagDefinition = {
+    errorHtml?: string;
+    fallbackHtml: string;
+    id: string;
+    resolver: string;
+    timeoutMs?: number;
+};
+export declare const extractStaticStreamingTags: (html: string) => StaticStreamingTagDefinition[];
+export declare const loadStaticStreamingSlots: (pagePath: string, html: string) => Promise<{
+    errorHtml: string | undefined;
+    fallbackHtml: string;
+    id: string;
+    resolve: StaticStreamingSlotResolver;
+    timeoutMs: number | undefined;
+}[]>;
+export {};

package/dist/src/core/streamingSlotRegistrar.d.ts

@@ -0,0 +1,16 @@
+import type { StreamingSlot } from '../utils/streamingSlots';
+type StreamingSlotRegistrar = (slot: StreamingSlot) => void;
+type StreamingSlotWarningController = {
+    maybeWarn(primitiveName: string): void;
+};
+type StreamingSlotCollectionController = {
+    isCollecting(): boolean;
+};
+export declare const hasRegisteredStreamingSlotRegistrar: () => boolean;
+export declare const isStreamingSlotCollectionActive: () => boolean;
+export declare const registerStreamingSlot: (slot: StreamingSlot) => void;
+export declare const setStreamingSlotCollectionController: (controller: StreamingSlotCollectionController | null) => void;
+export declare const setStreamingSlotRegistrar: (nextRegistrar: StreamingSlotRegistrar | null) => void;
+export declare const setStreamingSlotWarningController: (controller: StreamingSlotWarningController | null) => void;
+export declare const warnMissingStreamingSlotCollector: (primitiveName: string) => void;
+export {};

package/dist/src/core/streamingSlotRegistry.d.ts

@@ -0,0 +1,2 @@
+export declare const hasActiveStreamingSlotRegistry: () => boolean;
+export declare const runWithStreamingSlotRegistry: <T>(task: () => Promise<T> | T) => Promise<any>;

package/dist/src/core/streamingSlotWarningScope.d.ts

@@ -0,0 +1,4 @@
+export declare const captureStreamingSlotWarningCallsite: () => string | undefined;
+export declare const runWithStreamingSlotWarningScope: <T>(task: () => Promise<T> | T, metadata?: {
+    handlerCallsite?: string;
+}) => T | Promise<T>;

package/dist/src/core/svelteServerModule.d.ts

@@ -0,0 +1 @@
+export declare const compileSvelteServerModule: (sourcePath: string) => Promise<string>;

package/dist/src/core/vueServerModule.d.ts

@@ -0,0 +1 @@
+export declare const compileVueServerModule: (sourcePath: string) => Promise<string>;

package/dist/src/core/wrapPageHandlerWithStreamingSlots.d.ts

@@ -0,0 +1,2 @@
+import { withRegisteredStreamingSlots } from './responseEnhancers';
+export declare const wrapPageHandlerWithStreamingSlots: <T extends (...args: unknown[]) => Response | Promise<Response>>(handler: T, options?: Parameters<typeof withRegisteredStreamingSlots>[1]) => (...args: Parameters<T>) => Promise<Response>;