@hyperfrontend/builder 0.1.0

package/bundle/fs/empty-dirs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Post-order removal of every empty directory under `root` (`root` itself is
+ * left intact).
+ *
+ * Children are visited before their parent so a directory whose only contents
+ * are now-empty subdirectories is itself removed in the same pass.
+ *
+ * @param root - Absolute path to the directory whose empty descendants should be
+ * pruned. Assumed to exist; only its descendants are candidates for removal.
+ * @returns The number of directories removed.
+ *
+ * @example Sweeping a package output tree
+ * ```typescript
+ * const removed = removeEmptyDirs(context.outputPath)
+ * ```
+ */
+export declare const removeEmptyDirs: (root: string) => number;
+//# sourceMappingURL=empty-dirs.d.ts.map

package/bundle/fs/empty-dirs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-dirs.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/fs/empty-dirs.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAW9C,CAAA"}

package/bundle/fs/entry-dir.d.ts

@@ -0,0 +1,21 @@
+import type { BuildContext, EntryPoint } from '../../models';
+/**
+ * Resolves an entry point's absolute output directory in the built package tree.
+ *
+ * The root entry (`src/index.ts`) emits straight into the package root, so it
+ * maps to `context.outputPath`; every other entry mirrors its `src/` subpath
+ * (e.g. `browser/v1`) under the output root. Post-emit passes use this to locate
+ * the on-disk directory an entry's bundle, declarations, and chunks live in.
+ *
+ * @param entry - The resolved entry point whose output directory is wanted.
+ * @param context - Build context supplying the absolute output root.
+ * @returns Absolute path to the entry's output directory.
+ *
+ * @example Locating a feature entry's output directory
+ * ```typescript
+ * // entry.srcPath === 'browser/v1' → '<outputPath>/browser/v1'
+ * const dir = entryDirOf(entry, context)
+ * ```
+ */
+export declare const entryDirOf: (entry: EntryPoint, context: BuildContext) => string;
+//# sourceMappingURL=entry-dir.d.ts.map

package/bundle/fs/entry-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-dir.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/fs/entry-dir.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG5D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,UAAU,EAAE,SAAS,YAAY,KAAG,MACO,CAAA"}

package/bundle/fs/posix-path.d.ts

@@ -0,0 +1,30 @@
+/**
+ * POSIX-normalises a path so all separators are `/`.
+ *
+ * @param value - Raw path that may contain backslashes (Windows) or forward slashes.
+ * @returns Path with all separators normalized to `/`.
+ *
+ * @example Normalising a Windows-style path
+ * ```typescript
+ * normalizeToForwardSlashes('a\\b\\index.d.ts') // => 'a/b/index.d.ts'
+ * ```
+ */
+export declare const normalizeToForwardSlashes: (value: string) => string;
+/**
+ * POSIX-style path joiner: joins segments via `node:path` then normalizes all
+ * separators to `/`, so output is stable across Windows and POSIX hosts.
+ *
+ * Depends on nothing but `node:path` by design: worker-reachable callers bootstrap
+ * from source before workspace packages are guaranteed loadable, so this module must
+ * not import `@hyperfrontend/*`.
+ *
+ * @param segments - Path segments to join.
+ * @returns Joined path with `/` separators.
+ *
+ * @example Joining segments into a POSIX path
+ * ```typescript
+ * join('/abs/dist/libs/foo', 'models', 'index.d.ts') // => '/abs/dist/libs/foo/models/index.d.ts'
+ * ```
+ */
+export declare const join: (...segments: string[]) => string;
+//# sourceMappingURL=posix-path.d.ts.map

package/bundle/fs/posix-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posix-path.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/fs/posix-path.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,KAAG,MAAmC,CAAA;AAE7F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,UAAU,MAAM,EAAE,KAAG,MAA0D,CAAA"}

package/bundle/fs/under-dir.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tests whether `path` is `dir` itself or lies anywhere beneath it.
+ *
+ * A pure lexical check: `path` is contained when it equals `dir` or starts with
+ * `dir/`. The trailing-slash guard keeps a sibling like `_dependencies-old` from
+ * matching `_dependencies`. Post-emit passes use it to enforce the
+ * `_dependencies/` "never touch" invariant.
+ *
+ * @param path - Absolute path to test.
+ * @param dir - Absolute directory path that may contain `path`.
+ * @returns `true` when `path` equals `dir` or lies under `dir/`.
+ *
+ * @example Guarding the `_dependencies/` never-touch invariant
+ * ```typescript
+ * if (isUnderDir(candidate, depsRoot)) continue // never touch bundled deps
+ * ```
+ */
+export declare const isUnderDir: (path: string, dir: string) => boolean;
+//# sourceMappingURL=under-dir.d.ts.map

package/bundle/fs/under-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"under-dir.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/fs/under-dir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,KAAK,MAAM,KAAG,OAAqD,CAAA"}