@jay-framework/production-build 0.24.2

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { BuildOptions, RouteManifest, InstanceEntry, RouteEntry, ActionEntry, PluginEntry } from '@jay-framework/production-server';
+export * from '@jay-framework/production-server';
+import { JayRollupConfig } from '@jay-framework/compiler-jay-stack';
+import { JayRoute, JayRoutes } from '@jay-framework/stack-route-scanner';
+import { JayHtmlHeadMeta } from '@jay-framework/compiler-shared';
+import { HeadlessContractInfo, DiscoveredHeadlessInstance, ForEachHeadlessInstance } from '@jay-framework/compiler-jay-html';
+import { DevServerPagePart, HeadlessInstanceComponent } from '@jay-framework/stack-server-runtime';
+
+declare function buildVersion(options: BuildOptions): Promise<RouteManifest>;
+
+interface ClientInitEntry {
+    modulePath: string;
+    exportName: string;
+    key: string;
+}
+interface InstanceBuildContext {
+    projectRoot: string;
+    pagesRoot: string;
+    buildDir: string;
+    backendDir: string;
+    frontendDir: string;
+    jayOptions: JayRollupConfig;
+    tsConfigFilePath?: string;
+    minify?: boolean;
+    clientInits?: ClientInitEntry[];
+    /** When set, appended to instance ID hash to produce unique filenames per rebuild. */
+    rebuildSuffix?: string;
+}
+type InstanceBuildResult = {
+    status: 'success';
+    instanceEntry: InstanceEntry;
+    slowViewState: object;
+    carryForward: object;
+    contracts: string[];
+} | {
+    status: 'skipped';
+    reason: string;
+};
+declare function buildInstance(route: JayRoute, params: Record<string, string>, pageModule: any, ctx: InstanceBuildContext, routeServerElementPath?: string, routeCssPath?: string, routeHydratePath?: string, routeClientBundlePath?: string): Promise<InstanceBuildResult>;
+
+interface InstanceClientBuildResult {
+    jsFile: string;
+    cssFile?: string;
+}
+declare function buildInstanceClient(hydrateEntryPath: string, instanceId: string, outputDir: string, projectRoot: string, jayOptions: JayRollupConfig, minify?: boolean, pagesRoot?: string, buildDir?: string): Promise<InstanceClientBuildResult>;
+
+interface ServerElementCompileResult {
+    cssFile?: string;
+    /** External URLs extracted from @import rules (e.g., Google Fonts) */
+    cssImports?: string[];
+    headMeta?: JayHtmlHeadMeta;
+}
+/**
+ * Compile a per-route server element from the original jay-html (DL#144).
+ * All bindings (slow, fast, interactive) are dynamic — read from ViewState at render time.
+ *
+ * Unlike per-instance compilation where jayHtmlDir === outputDir, here the source
+ * directory differs from the output directory. We resolve all relative paths in the
+ * jay-html to absolute before parsing, so the generated TypeScript imports are
+ * resolvable from the output directory.
+ */
+declare function compileRouteServerElement(jayHtmlPath: string, outputPath: string, projectRoot: string, tsConfigFilePath?: string, minifyCss?: boolean): Promise<ServerElementCompileResult>;
+interface RouteHydrateCompileResult {
+    jsFile: string;
+}
+/**
+ * Compile a per-route hydrate script from the original jay-html (DL#144).
+ * Phase-aware: only interactive bindings get coordinates and adoption code.
+ * Produces a client-side ES module that exports `hydrate()`.
+ */
+declare function compileRouteHydrateScript(jayHtmlPath: string, outputDir: string, projectRoot: string, tsConfigFilePath?: string, minify?: boolean): Promise<RouteHydrateCompileResult>;
+
+interface SharedChunksBuildResult {
+    manifest: Record<string, string>;
+    outputDir: string;
+}
+declare function buildSharedChunks(outputDir: string, _projectRoot: string, minify?: boolean, pluginClientPackages?: string[]): Promise<SharedChunksBuildResult>;
+
+interface ServerBuildEntries {
+    init?: string;
+    pages: Record<string, string>;
+    actions: Record<string, string>;
+}
+declare function discoverServerEntries(projectRoot: string, pagesRoot: string): Promise<{
+    entries: ServerBuildEntries;
+    routes: JayRoute[];
+}>;
+declare function buildServerCode(entries: ServerBuildEntries, jayOptions: JayRollupConfig, outputDir: string, projectRoot: string): Promise<void>;
+
+interface KeyedPartModule {
+    key: string;
+    modulePath: string;
+    exportName: string;
+}
+interface HeadlessModuleInfo {
+    modulePath: string;
+    exportName: string;
+    isLocal: boolean;
+    contractName?: string;
+    key?: string;
+    propNames?: string[];
+    contractInfo?: {
+        contractName: string;
+        metadata?: Record<string, unknown>;
+    };
+    headlessProps?: Record<string, string>;
+    structural?: boolean;
+}
+interface ProductionPageParts {
+    parts: DevServerPagePart[];
+    headlessContracts: HeadlessContractInfo[];
+    headlessInstanceComponents: HeadlessInstanceComponent[];
+    discoveredInstances: DiscoveredHeadlessInstance[];
+    forEachInstances: ForEachHeadlessInstance[];
+    keyedPartModules: KeyedPartModule[];
+    headlessModuleInfos: HeadlessModuleInfo[];
+    serverTrackByMap?: Record<string, string>;
+    clientTrackByMap?: Record<string, string>;
+}
+declare function loadProductionPageParts(route: JayRoute | {
+    jayHtmlPath: string;
+    componentExport?: string;
+}, pageModule: any, jayHtmlContent: string, projectRoot: string, tsConfigFilePath?: string, serverBuildDir?: string): Promise<ProductionPageParts>;
+interface PagePartsConfigEntry {
+    modulePath: string;
+    exportName: string;
+    source: 'npm' | 'local';
+    structural?: boolean;
+}
+interface PagePartsConfig {
+    parts: Array<PagePartsConfigEntry & {
+        key?: string;
+        contractInfo?: {
+            contractName: string;
+            metadata?: Record<string, unknown>;
+        };
+        headlessProps?: Record<string, string>;
+    }>;
+    instanceComponents: Array<PagePartsConfigEntry & {
+        contractName: string;
+        propNames: string[];
+    }>;
+    forEachInstances: Array<{
+        contractName: string;
+        forEachPath: string;
+        trackBy: string;
+        propBindings: Record<string, string>;
+        coordinateSuffix: string;
+    }>;
+}
+declare function buildPagePartsConfig(pageParts: ProductionPageParts, pageServerModule: string, pageExportName: string, buildDir: string, pageIsPlugin?: boolean): PagePartsConfig;
+
+interface RouteInfo {
+    rawRoute: string;
+    inferredParams?: Record<string, string>;
+    optionalSegments?: Set<string>;
+    hasDynamicParams: boolean;
+}
+interface ParamPart {
+    keys: Set<string>;
+    values: Record<string, string>[];
+}
+interface MaterializedEntry<R extends RouteInfo = RouteInfo> {
+    route: R;
+    params: Record<string, string>;
+    url: string;
+    specificity: number;
+}
+declare function crossProductParams(parts: ParamPart[]): Record<string, string>[];
+declare function computeSpecificity(route: RouteInfo): number;
+declare function buildUrl(route: RouteInfo, params: Record<string, string>): string;
+declare function materializeRouteParams<R extends RouteInfo>(routes: R[], loadParamsResults: Map<R, Record<string, string>[]>): MaterializedEntry<R>[];
+declare function dedupeByUrl<R extends RouteInfo>(entries: MaterializedEntry<R>[]): MaterializedEntry<R>[];
+
+declare function buildRouteEntry(route: JayRoute, serverModulePath: string): RouteEntry;
+declare function discoverActions(actionPaths: Record<string, string>, serverOutputDir: string, buildDir: string, projectRoot: string): Promise<{
+    actions: ActionEntry[];
+    plugins: PluginEntry[];
+}>;
+declare function writeRouteManifest(manifest: RouteManifest, buildDir: string): Promise<void>;
+
+interface KeyedPartInfo {
+    key: string;
+    modulePath: string;
+    exportName: string;
+}
+interface ClientInitInfo {
+    modulePath: string;
+    exportName: string;
+    key: string;
+}
+interface RouteHydrationEntryOptions {
+    hydrateImport: string;
+    pageModulePath: string;
+    pageExportName?: string;
+    trackByMap: Record<string, string>;
+    outputPath: string;
+    keyedParts?: KeyedPartInfo[];
+    clientInits?: ClientInitInfo[];
+}
+/**
+ * Generate a per-route hydration entry (DL#144).
+ * slowViewState is received as a parameter to init() instead of baked as a literal.
+ * This makes the entry identical across all instances of a route.
+ */
+declare function generateRouteHydrationEntry(options: RouteHydrationEntryOptions): Promise<void>;
+
+declare function scanPluginRoutes(projectRoot: string, projectRoutes: JayRoutes): Promise<JayRoutes>;
+
+export { type InstanceBuildContext, type InstanceBuildResult, type InstanceClientBuildResult, type MaterializedEntry, type ParamPart, type RouteInfo, buildInstance, buildInstanceClient, buildPagePartsConfig, buildRouteEntry, buildServerCode, buildSharedChunks, buildUrl, buildVersion, compileRouteHydrateScript, compileRouteServerElement, computeSpecificity, crossProductParams, dedupeByUrl, discoverActions, discoverServerEntries, generateRouteHydrationEntry, loadProductionPageParts, materializeRouteParams, scanPluginRoutes, writeRouteManifest };