@hyperfrontend/builder 0.1.0

package/bundle/dedupe/plan-hoists.d.ts

@@ -0,0 +1,46 @@
+import type { EntryDecl, ModuleKey, OwnerIndex, ParsedEntry } from './attribute-modules';
+import type { ModuleResolution } from './extract-chunk';
+/**
+ * One parsed entry bundle paired with its declarations grouped by owning module.
+ */
+export interface EntryInput {
+    /** The parsed entry bundle. */
+    parsed: ParsedEntry;
+    /** The entry's attributable declarations grouped by module key. */
+    byModule: Map<ModuleKey, EntryDecl[]>;
+}
+/**
+ * A module the plan will hoist into a shared chunk.
+ */
+export interface PlannedModule {
+    /** Index of the entry whose copy defines the canonical chunk content and order. */
+    canonicalEntryIndex: number;
+    /** Canonical declarations, in source order, that populate the chunk. */
+    decls: EntryDecl[];
+    /** Resolved references the chunk must re-import. */
+    resolution: ModuleResolution;
+    /** Indexes of every entry that inlines this module and must be rewritten. */
+    consumingEntryIndexes: number[];
+}
+/**
+ * Plans which first-party modules can be hoisted into shared chunks.
+ *
+ * A module qualifies only when it is inlined into at least two entries, is not
+ * entangled with a bare statement, presents structurally identical declarations
+ * (rename-insensitive) in a consistent order across every copy, references
+ * nothing unresolvable, and —
+ * after closure and acyclic peeling — depends only on other hoisted modules
+ * through a cycle-free graph. Anything failing these is left inlined, so the
+ * worst case equals the unmodified output.
+ *
+ * @param entries - Parsed entries with their per-module attribution.
+ * @param owners - First-party ownership index.
+ * @returns Map from module key to its hoist plan.
+ *
+ * @example Planning hoists for a set of entries
+ * ```typescript
+ * const plan = planHoists(entries, owners)
+ * ```
+ */
+export declare const planHoists: (entries: EntryInput[], owners: OwnerIndex) => Map<ModuleKey, PlannedModule>;
+//# sourceMappingURL=plan-hoists.d.ts.map

package/bundle/dedupe/plan-hoists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-hoists.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dedupe/plan-hoists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAQvD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,+BAA+B;IAC/B,MAAM,EAAE,WAAW,CAAA;IACnB,mEAAmE;IACnE,QAAQ,EAAE,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAA;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mFAAmF;IACnF,mBAAmB,EAAE,MAAM,CAAA;IAC3B,wEAAwE;IACxE,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,oDAAoD;IACpD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,EAAE,CAAA;CAChC;AA4GD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,UAAU,EAAE,EAAE,QAAQ,UAAU,KAAG,GAAG,CAAC,SAAS,EAAE,aAAa,CASlG,CAAA"}

package/bundle/dedupe/rewrite-entry.d.ts

@@ -0,0 +1,39 @@
+import type { ChunkFormat } from '../dependencies/prune/used-exports';
+import type { EntryDecl, ParsedEntry } from './attribute-modules';
+/**
+ * One module's hoist within a single entry: the declarations to splice out and
+ * the chunk specifier the entry should import them from.
+ */
+export interface EntryHoist {
+    /** The module's declarations as they appear in this entry. */
+    decls: EntryDecl[];
+    /** Chunk-relative module specifier reaching the module's shared chunk. */
+    specifier: string;
+}
+/**
+ * Rewrites an entry bundle to consume hoisted modules from `_shared/` chunks
+ * instead of inlining them.
+ *
+ * Splices every hoisted declaration (and its leading comments) out of the entry
+ * and prepends an import/`require` binding the chunk's base export to the
+ * entry's local name — aliasing when rollup renamed the local (`foo as foo$1`).
+ * Only the hoisted symbols the entry still references after splicing are
+ * re-imported: a private helper used solely by another hoisted export (e.g. a
+ * reducer's `handlers`, used only by the hoisted `rootReducer`) is seen as dead
+ * against the spliced body and omitted from the import, while the chunk it lives
+ * in keeps it. The bundle's export surface is left untouched: surviving spliced
+ * names are now supplied by the inserted imports, so the published API is
+ * byte-for-byte identical to before.
+ *
+ * @param parsed - The parsed entry bundle.
+ * @param hoists - The modules hoisted out of this entry, each with its chunk specifier.
+ * @param format - Output module format.
+ * @returns The rewritten entry source, or the original source when `hoists` is empty.
+ *
+ * @example Rewriting an entry to import a shared module
+ * ```typescript
+ * const rewritten = rewriteEntry(parseEntry(source, 'esm'), [{ decls, specifier: './_shared/state/index.esm.js' }], 'esm')
+ * ```
+ */
+export declare const rewriteEntry: (parsed: ParsedEntry, hoists: EntryHoist[], format: ChunkFormat) => string;
+//# sourceMappingURL=rewrite-entry.d.ts.map

package/bundle/dedupe/rewrite-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite-entry.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dedupe/rewrite-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAMjE;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;CAClB;AAsCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,WAAW,EAAE,QAAQ,UAAU,EAAE,EAAE,QAAQ,WAAW,KAAG,MAe7F,CAAA"}

package/bundle/dependencies/collect-workspace-deps.d.ts

@@ -0,0 +1,34 @@
+import type { BuildContext } from '../../models';
+/**
+ * Collects the distinct `whole-surface` workspace package names from the build
+ * context — the packages whose entire import surface is hoisted into
+ * `_dependencies/<packageName>/`.
+ *
+ * Supplies the `otherDeps` prefix list a job passes to the externalize plugin.
+ *
+ * @param context - Build context supplying `workspaceBundledDeps`.
+ * @returns De-duplicated `whole-surface` package names.
+ *
+ * @example Collecting whole-surface prefixes for a job's `otherDeps`
+ * ```typescript
+ * otherDeps: [...context.bundledDeps, ...collectWorkspacePrefixDeps(context)]
+ * ```
+ */
+export declare const collectWorkspacePrefixDeps: (context: BuildContext) => string[];
+/**
+ * Collects the distinct `sub-path` workspace specifiers from the build context —
+ * the exact `@scope/pkg/sub` imports that are hoisted individually rather than
+ * across the whole package surface.
+ *
+ * Supplies the `otherWorkspaceSpecifiers` list a job hands the externalize plugin.
+ *
+ * @param context - Build context supplying `workspaceBundledDeps`.
+ * @returns De-duplicated `sub-path` specifiers.
+ *
+ * @example Collecting sub-path specifiers for a job's `otherWorkspaceSpecifiers`
+ * ```typescript
+ * otherWorkspaceSpecifiers: collectWorkspaceExactSpecifiers(context)
+ * ```
+ */
+export declare const collectWorkspaceExactSpecifiers: (context: BuildContext) => string[];
+//# sourceMappingURL=collect-workspace-deps.d.ts.map

package/bundle/dependencies/collect-workspace-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-workspace-deps.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/collect-workspace-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAIhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,YAAY,KAAG,MAAM,EAMxE,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,+BAA+B,GAAI,SAAS,YAAY,KAAG,MAAM,EAM7E,CAAA"}

package/bundle/dependencies/externalize-plugin.d.ts

@@ -0,0 +1,100 @@
+import type { Plugin } from 'rollup';
+import type { WorkspaceBundledDep } from '../../models';
+/**
+ * Format produced by the rollup invocation that uses the plugin.
+ *
+ * D.ts passes use `'dts'` so the plugin maps imports to `.d.ts` siblings under
+ * `_dependencies/<dep>/`; JS passes use `'esm'` / `'cjs'`.
+ */
+export type ExternalizeFormat = 'esm' | 'cjs' | 'dts';
+/**
+ * Computes the relative import specifier that a rollup output at `fromDir`
+ * needs to use to reach `toFile`. The result always uses POSIX separators and
+ * starts with `./` or `../` so node treats it as a relative path.
+ *
+ * @param fromDir - Absolute directory containing the output file.
+ * @param toFile - Absolute path to the target file.
+ * @returns Relative import specifier ready for inclusion in emitted code.
+ *
+ * @example Computing the relative path to a bundled dep
+ * ```typescript
+ * relativeImport('/abs/dist/libs/foo/bundle/rollup', '/abs/dist/libs/foo/_dependencies/rollup/index.esm.js')
+ * // => '../../_dependencies/rollup/index.esm.js'
+ * ```
+ */
+export declare const relativeImport: (fromDir: string, toFile: string) => string;
+/**
+ * Per-package workspace-dep routing entry.
+ *
+ * - `policy: 'whole-surface'` collapses every import of `<packageName>` (root or
+ *   sub-path) onto the single root chunk at `_dependencies/<packageName>/index.<ext>`.
+ * - `policy: 'sub-path'` matches each pre-passed specifier exactly; non-matched
+ *   sub-path imports of the same package fall through unchanged so the rest of
+ *   the plugin chain can resolve / inline them.
+ */
+export interface WorkspaceBundledDepRoute {
+    /** Workspace package name (e.g. `@hyperfrontend/logging`). */
+    packageName: string;
+    /** Routing policy applied to imports of this package. */
+    policy: 'whole-surface' | 'sub-path';
+    /** When `policy === 'sub-path'`: the exact specifiers that were pre-passed. */
+    specifiers?: string[];
+}
+/**
+ * Inputs to {@link createExternalizeBundledDepsPlugin}.
+ */
+export interface ExternalizeBundledDepsPluginOptions {
+    /** Bundled-dep package names. Any import of these (or their subpaths) is rerouted to `_dependencies/<dep>/`. */
+    deps: string[];
+    /** Absolute directory the rollup invocation writes its output to. */
+    entryOutDir: string;
+    /** Format being produced by this rollup invocation. */
+    format: ExternalizeFormat;
+    /** Absolute path to the `_dependencies/` root. */
+    depsRoot: string;
+    /** Workspace bundled-dep routes. Imports of these packages reroute to `_dependencies/<packageName>(/<sub>)?/`. */
+    workspaceRoutes?: WorkspaceBundledDepRoute[];
+}
+/**
+ * Groups `WorkspaceBundledDep` entries into per-package `WorkspaceBundledDepRoute`
+ * shapes consumable by {@link createExternalizeBundledDepsPlugin}.
+ *
+ * Whole-surface deps emit a single route with no specifiers; sub-path deps emit
+ * a route enumerating each pre-passed specifier so the plugin can match exactly.
+ *
+ * @param entries - Workspace bundled-dep entries from `BuildContext.workspaceBundledDeps`.
+ * @returns Routes ready to feed into the externalize plugin.
+ *
+ * @example Building plugin routes from the build context
+ * ```typescript
+ * const routes = buildWorkspaceRoutes(context.workspaceBundledDeps)
+ * createExternalizeBundledDepsPlugin({ deps, entryOutDir, format, depsRoot, workspaceRoutes: routes })
+ * ```
+ */
+export declare const buildWorkspaceRoutes: (entries: WorkspaceBundledDep[]) => WorkspaceBundledDepRoute[];
+/**
+ * Returns a rollup plugin whose `resolveId` hook maps any import of a bundled
+ * dep (or its subpath) to a relative import that points at the pre-passed
+ * artifact under `_dependencies/<dep>/`. With `workspaceRoutes` populated, the
+ * plugin also routes workspace `@hyperfrontend/*` imports through the matching
+ * workspace chunk (whole-surface or sub-path mode per route).
+ *
+ * The plugin marks node builtins (and `node:*` imports) as external so they
+ * survive untouched, and returns `null` for everything else so the rest of the
+ * plugin chain can resolve normally.
+ *
+ * @param options - Plugin configuration.
+ * @returns Rollup plugin.
+ *
+ * @example Routing imports of `rollup` to the pre-passed copy
+ * ```typescript
+ * const plugin = createExternalizeBundledDepsPlugin({
+ *   deps: ['rollup'],
+ *   entryOutDir: '/abs/dist/libs/foo/bundle/rollup',
+ *   format: 'esm',
+ *   depsRoot: '/abs/dist/libs/foo/_dependencies',
+ * })
+ * ```
+ */
+export declare const createExternalizeBundledDepsPlugin: (options: ExternalizeBundledDepsPluginOptions) => Plugin;
+//# sourceMappingURL=externalize-plugin.d.ts.map

package/bundle/dependencies/externalize-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalize-plugin.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/externalize-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAKvD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAQrD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,MAKhE,CAAA;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAA;IACnB,yDAAyD;IACzD,MAAM,EAAE,eAAe,GAAG,UAAU,CAAA;IACpC,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,mCAAmC;IAClD,gHAAgH;IAChH,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,MAAM,EAAE,iBAAiB,CAAA;IACzB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAA;IAChB,kHAAkH;IAClH,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAA;CAC7C;AAiDD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,mBAAmB,EAAE,KAAG,wBAAwB,EAe7F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,kCAAkC,GAAI,SAAS,mCAAmC,KAAG,MAyBjG,CAAA"}