@codama/fragments 0.1.0

package/dist/types/core/mapFragmentContent.d.ts

@@ -0,0 +1,43 @@
+import type { BaseFragment } from './BaseFragment';
+/**
+ * Apply a synchronous transformation to a fragment's `content`, returning a
+ * new fragment with every other field preserved.
+ *
+ * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.
+ * @param fragment - The source fragment.
+ * @param mapContent - A function that receives the current content and
+ * returns the new content.
+ * @return A frozen fragment with the transformed content.
+ *
+ * @example
+ * ```ts
+ * import { mapFragmentContent } from '@codama/fragments';
+ *
+ * const trimmed = mapFragmentContent(fragment, c => c.trimEnd());
+ * ```
+ *
+ * @see {@link mapFragmentContentAsync} for the async variant.
+ */
+export declare function mapFragmentContent<TFragment extends BaseFragment>(fragment: TFragment, mapContent: (content: string) => string): TFragment;
+/**
+ * Async variant of {@link mapFragmentContent}: apply an async transformation
+ * to a fragment's `content`.
+ *
+ * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.
+ * @param fragment - The source fragment.
+ * @param mapContent - An async function that receives the current content
+ * and returns a promise resolving to the new content.
+ * @return A promise that resolves to a frozen fragment with the transformed
+ * content.
+ *
+ * @example
+ * ```ts
+ * import { mapFragmentContentAsync } from '@codama/fragments';
+ *
+ * const formatted = await mapFragmentContentAsync(fragment, formatWithPrettier);
+ * ```
+ *
+ * @see {@link mapFragmentContent} for the sync variant.
+ */
+export declare function mapFragmentContentAsync<TFragment extends BaseFragment>(fragment: TFragment, mapContent: (content: string) => Promise<string>): Promise<TFragment>;
+//# sourceMappingURL=mapFragmentContent.d.ts.map

package/dist/types/core/mapFragmentContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapFragmentContent.d.ts","sourceRoot":"","sources":["../../../src/core/mapFragmentContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,SAAS,YAAY,EAC7D,QAAQ,EAAE,SAAS,EACnB,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACxC,SAAS,CAEX;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,SAAS,YAAY,EACxE,QAAQ,EAAE,SAAS,EACnB,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GACjD,OAAO,CAAC,SAAS,CAAC,CAEpB"}

package/dist/types/core/path.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Path manipulation helpers used by code generators to assemble output
+ * file paths.
+ *
+ * The {@link Path} type is a thin documentation alias for `string` —
+ * any place a generator stores or threads a filesystem-relative path,
+ * use this name to communicate intent. The {@link joinPath} and
+ * {@link pathDirectory} helpers delegate to `node:path` on Node and
+ * fall back to lightweight string manipulation on non-Node platforms.
+ */
+/** A filesystem path inside the generator's output tree. */
+export type Path = string;
+/**
+ * Join two or more path segments together. Uses `node:path`'s
+ * platform-aware {@link join} on Node; on other platforms (browser,
+ * react-native) falls back to a `/`-joined form with consecutive
+ * slashes collapsed.
+ */
+export declare function joinPath(...paths: Path[]): string;
+/**
+ * Return the directory portion of a path (i.e. everything up to the
+ * last `/` segment). Uses `node:path`'s {@link dirname} on Node and a
+ * plain `lastIndexOf` fallback on other platforms.
+ */
+export declare function pathDirectory(path: Path): Path;
+/**
+ * Return the trailing segment of a path (everything after the last
+ * `/`). Uses `node:path`'s {@link basename} on Node and a plain
+ * `lastIndexOf` fallback on other platforms.
+ */
+export declare function pathBasename(path: Path): Path;
+/**
+ * Compute the POSIX-style relative path from `from` to `to`. Both
+ * arguments are treated as `/`-separated logical paths regardless of
+ * platform, so the result is consistent across operating systems —
+ * suitable for emitting into source code as an import specifier.
+ *
+ * Node only: non-Node platforms throw {@link CodamaError} because
+ * implementing a correct POSIX relative-path algorithm without
+ * `node:path` is non-trivial and no current consumer needs it.
+ */
+export declare function relativePath(from: Path, to: Path): string;
+//# sourceMappingURL=path.d.ts.map

package/dist/types/core/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/core/path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,4DAA4D;AAC5D,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAMjD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAM9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAO7C;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAMzD"}

package/dist/types/core/renderMap.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A `RenderMap` is the in-memory data structure a code generator builds
+ * up before writing anything to disk: a frozen `ReadonlyMap` keyed by
+ * output path, with a `BaseFragment` (or a concrete subtype carrying
+ * imports / features / …) as the value. The helpers in this module are
+ * pure data operations — they construct, merge, transform, and query
+ * render maps without touching the filesystem.
+ *
+ * {@link writeRenderMap} is the single filesystem-touching entry point
+ * here: it walks a finished map and writes every entry. Renderers that
+ * tie a render map to a `Visitor` (see `@codama/renderers-core`) layer
+ * that on top.
+ */
+import type { BaseFragment } from './BaseFragment';
+import { type Path } from './path';
+/**
+ * A frozen map keyed by output {@link Path}, with each entry holding a
+ * fragment that will be written to that path. `TFragment` defaults to
+ * {@link BaseFragment} but generators typically pass a richer flavor
+ * (e.g. `Fragment` from `@codama/fragments/javascript`) to carry
+ * imports and other per-file metadata.
+ */
+export type RenderMap<TFragment extends BaseFragment> = ReadonlyMap<Path, TFragment>;
+export declare function createRenderMap<TFragment extends BaseFragment = BaseFragment>(): RenderMap<TFragment>;
+export declare function createRenderMap<TFragment extends BaseFragment>(path: Path, content: TFragment): RenderMap<TFragment>;
+export declare function createRenderMap<TFragment extends BaseFragment>(entries: Record<Path, TFragment | undefined>): RenderMap<TFragment>;
+/** Add or overwrite a single `(path, fragment)` entry. */
+export declare function addToRenderMap<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, path: Path, content: TFragment): RenderMap<TFragment>;
+/** Remove the entry at `path`, returning a new frozen map. */
+export declare function removeFromRenderMap<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, path: Path): RenderMap<TFragment>;
+/**
+ * Combine multiple render maps into one. Later maps overwrite earlier
+ * entries at the same path.
+ */
+export declare function mergeRenderMaps<TFragment extends BaseFragment>(renderMaps: RenderMap<TFragment>[]): RenderMap<TFragment>;
+/** Transform every fragment in the map, preserving the keys. */
+export declare function mapRenderMapFragment<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, fn: (fragment: TFragment, path: Path) => TFragment): RenderMap<TFragment>;
+/** Async variant of {@link mapRenderMapFragment}. */
+export declare function mapRenderMapFragmentAsync<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, fn: (fragment: TFragment, path: Path) => Promise<TFragment>): Promise<RenderMap<TFragment>>;
+/** Transform the `content` of every fragment in the map. */
+export declare function mapRenderMapContent<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, fn: (content: string, path: Path) => string): RenderMap<TFragment>;
+/** Async variant of {@link mapRenderMapContent}. */
+export declare function mapRenderMapContentAsync<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, fn: (content: string, path: Path) => Promise<string>): Promise<RenderMap<TFragment>>;
+/**
+ * Look up the fragment at `path`, throwing a structured
+ * {@link CodamaError} when the key is missing.
+ */
+export declare function getFromRenderMap<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, path: Path): TFragment;
+/**
+ * Test whether the fragment at `path` contains `value`. Accepts either
+ * a plain substring or a regular expression.
+ */
+export declare function renderMapContains<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, path: Path, value: RegExp | string): boolean;
+/**
+ * Walk the render map and write every entry to disk, rooted at
+ * `basePath`. Each path is joined with `basePath` via {@link joinPath}
+ * and written via {@link writeFile}; the directory structure is
+ * created on demand.
+ */
+export declare function writeRenderMap<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, basePath: Path): void;
+//# sourceMappingURL=renderMap.d.ts.map

package/dist/types/core/renderMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderMap.d.ts","sourceRoot":"","sources":["../../../src/core/renderMap.ts"],"names":[],"mappings":"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"}

package/dist/types/core/setFragmentContent.d.ts

@@ -0,0 +1,23 @@
+import type { BaseFragment } from './BaseFragment';
+/**
+ * Return a new frozen fragment whose `content` field has been replaced with
+ * `content`, preserving every other field of the input fragment.
+ *
+ * The output keeps the input's exact concrete type (`TFragment`) so callers
+ * never lose any extra fields a flavored fragment may carry (imports,
+ * features, etc.).
+ *
+ * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.
+ * @param fragment - The source fragment to copy.
+ * @param content - The new code string.
+ * @return A frozen fragment of the same shape as `fragment` with `content` replaced.
+ *
+ * @example
+ * ```ts
+ * import { setFragmentContent } from '@codama/fragments';
+ *
+ * const next = setFragmentContent(prev, prev.content.toUpperCase());
+ * ```
+ */
+export declare function setFragmentContent<TFragment extends BaseFragment>(fragment: TFragment, content: string): TFragment;
+//# sourceMappingURL=setFragmentContent.d.ts.map

package/dist/types/core/setFragmentContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setFragmentContent.d.ts","sourceRoot":"","sources":["../../../src/core/setFragmentContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,SAAS,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAElH"}

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@codama/fragments`
+ *
+ * The root entrypoint exposes only the language-agnostic core primitives
+ * (`BaseFragment`, `createFragmentTemplate`, `mapFragmentContent`, etc.).
+ * Language-aware code — concrete `Fragment` types, `ImportMap` shapes, and
+ * `fragment` tagged templates — lives under language subpaths:
+ *
+ *   import { fragment, use, renderPage } from '@codama/fragments/javascript';
+ *   import { fragment, addFragmentImports } from '@codama/fragments/rust';
+ *
+ * Generators that don't need language-specific behavior — for example,
+ * because they only manipulate the shared `BaseFragment` shape — should
+ * import from this root entrypoint.
+ */
+export * from './core';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,cAAc,QAAQ,CAAC"}

package/dist/types/javascript/ImportMap.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The data model used by `@codama/fragments/javascript` to track imports
+ * symbolically until they are stringified into actual `import { … } from '…';`
+ * lines.
+ *
+ * Imports are accumulated as a `ReadonlyMap<Module, ReadonlyMap<UsedIdentifier, ImportInfo>>`:
+ * outer key is the source module, inner key is the identifier used in the
+ * consuming code (which may differ from the imported name via aliasing).
+ *
+ * The format accepted by {@link parseImportInput} is a single string with
+ * the same shorthand TypeScript itself uses inside an `import { … }` block:
+ *
+ *   `Foo`                — value import; used as `Foo`
+ *   `type Foo`           — type-only import; used as `Foo`
+ *   `Foo as Bar`         — value import aliased; used as `Bar`
+ *   `type Foo as Bar`    — type-only import aliased; used as `Bar`
+ */
+/** A single import shorthand string. See the file-level docblock for the accepted forms. */
+export type ImportInput = string;
+/** A module path: either an absolute (`@scope/pkg`, `pkg`, `pkg/sub`) or a relative (`./foo`, `../bar`) specifier. */
+export type Module = string;
+/** The identifier as it appears in the consuming code (after aliasing). */
+export type UsedIdentifier = string;
+/** A parsed import shorthand. */
+export interface ImportInfo {
+    readonly importedIdentifier: string;
+    readonly isType: boolean;
+    readonly usedIdentifier: UsedIdentifier;
+}
+/** A symbolic import map keyed by module, then by used identifier. */
+export type ImportMap = ReadonlyMap<Module, ReadonlyMap<UsedIdentifier, ImportInfo>>;
+/**
+ * Construct an empty, frozen import map.
+ *
+ * @return A new {@link ImportMap} with no entries.
+ *
+ * @example
+ * ```ts
+ * import { createImportMap } from '@codama/fragments/javascript';
+ *
+ * const empty = createImportMap();
+ * ```
+ */
+export declare function createImportMap(): ImportMap;
+/**
+ * Parse a single import shorthand (e.g. `'type Foo as Bar'`) into a
+ * structured {@link ImportInfo}.
+ *
+ * @param input - The shorthand string to parse.
+ * @return The parsed info. If the shorthand can't be matched (e.g. it
+ * contains illegal whitespace), the entire string is returned unchanged as
+ * both the imported and used identifier, with `isType: false`.
+ *
+ * @example
+ * ```ts
+ * parseImportInput('Foo');             // { importedIdentifier: 'Foo', usedIdentifier: 'Foo', isType: false }
+ * parseImportInput('type Foo as Bar'); // { importedIdentifier: 'Foo', usedIdentifier: 'Bar', isType: true }
+ * ```
+ */
+export declare function parseImportInput(input: ImportInput): ImportInfo;
+//# sourceMappingURL=ImportMap.d.ts.map

package/dist/types/javascript/ImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportMap.d.ts","sourceRoot":"","sources":["../../../src/javascript/ImportMap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,4FAA4F;AAC5F,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,sHAAsH;AACtH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC,iCAAiC;AACjC,MAAM,WAAW,UAAU;IACvB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CAC3C;AAED,sEAAsE;AACtE,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;AAErF;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,IAAI,SAAS,CAE3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAe/D"}

package/dist/types/javascript/addToImportMap.d.ts

@@ -0,0 +1,25 @@
+import type { ImportInput, ImportMap, Module } from './ImportMap';
+/**
+ * Append imports to a module entry, returning a new frozen import map. The
+ * input map is not mutated.
+ *
+ * Within a single batch, the same conflict-resolution rule that
+ * {@link mergeImportMaps} uses is applied — a value import always wins over
+ * a type-only import of the same identifier — so callers don't have to
+ * worry about input order when passing both.
+ *
+ * @param importMap - The import map to extend.
+ * @param module - The source module the imports come from.
+ * @param imports - The shorthand strings to add. Empty array short-circuits
+ * and returns `importMap` unchanged.
+ * @return A frozen import map that includes the new entries.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap } from '@codama/fragments/javascript';
+ *
+ * const map = addToImportMap(createImportMap(), './foo', ['type Foo', 'Bar']);
+ * ```
+ */
+export declare function addToImportMap(importMap: ImportMap, module: Module, imports: ImportInput[]): ImportMap;
+//# sourceMappingURL=addToImportMap.d.ts.map

package/dist/types/javascript/addToImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addToImportMap.d.ts","sourceRoot":"","sources":["../../../src/javascript/addToImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,WAAW,EAAE,SAAS,EAAE,MAAM,EAAkB,MAAM,aAAa,CAAC;AAI9F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,SAAS,CAWtG"}

package/dist/types/javascript/fragment.d.ts

@@ -0,0 +1,135 @@
+import type { BaseFragment } from '../core/BaseFragment';
+import type { ImportInput, ImportMap, Module, UsedIdentifier } from './ImportMap';
+/**
+ * The JavaScript-flavored fragment shape: {@link BaseFragment} plus a
+ * symbolic {@link ImportMap} carrying the imports the content depends on.
+ *
+ * Fragments are frozen and composable — interpolating one into another
+ * (via the {@link fragment} tag) propagates both content and imports, so
+ * generators can build code top-down without threading import bookkeeping
+ * through every helper.
+ */
+export type Fragment = BaseFragment & Readonly<{
+    imports: ImportMap;
+}>;
+/**
+ * Type guard for the JavaScript-flavored {@link Fragment} shape.
+ *
+ * @param value - The value to test.
+ * @return `true` when `value` is an object carrying both `content` and
+ * `imports` fields. The check is structural; downstream code that layers
+ * extra fields on top (e.g. a renderer's `features` set) will still match.
+ */
+export declare function isFragment(value: unknown): value is Fragment;
+/**
+ * Tagged-template helper for composing JavaScript-flavored fragments.
+ * Interpolated values may be:
+ *
+ *   - A {@link Fragment} — content is inlined and imports propagate.
+ *   - `undefined` — rendered as the empty string (handy for optional
+ *     sub-fragments).
+ *   - Anything else — coerced to a string via `String(value)`.
+ *
+ * @param template - The template-strings array supplied by the tag call site.
+ * @param items - The interpolated values, in order.
+ * @return A frozen {@link Fragment} with the merged content and imports.
+ *
+ * @example
+ * ```ts
+ * import { fragment, use } from '@codama/fragments/javascript';
+ *
+ * const pdaLink = use('type PdaLinkNode', '../linkNodes/PdaLinkNode');
+ * const body = fragment`
+ *     export interface AccountNode {
+ *         readonly pda?: ${pdaLink};
+ *     }
+ * `;
+ * ```
+ */
+export declare function fragment(template: TemplateStringsArray, ...items: unknown[]): Fragment;
+/**
+ * Combine multiple fragments into one. The merge strategy for content is
+ * supplied by the caller (`mergeContent`); imports are merged automatically
+ * via {@link mergeImportMaps}. Undefined inputs are skipped.
+ *
+ * @param fragments - The fragments to merge, in order.
+ * @param mergeContent - A function that produces the final content string
+ * from each surviving fragment's content.
+ * @return A frozen merged {@link Fragment}.
+ *
+ * @example
+ * ```ts
+ * import { fragment, mergeFragments } from '@codama/fragments/javascript';
+ *
+ * const merged = mergeFragments(
+ *     [fragment`a`, fragment`b`, fragment`c`],
+ *     parts => parts.join(', '),
+ * );
+ * ```
+ */
+export declare function mergeFragments(fragments: readonly (Fragment | undefined)[], mergeContent: (contents: string[]) => string): Fragment;
+/**
+ * Construct a fragment whose content is a single imported identifier and
+ * whose import map carries the corresponding import statement.
+ *
+ * The shorthand accepted in `importInput` is the same as
+ * {@link parseImportInput}'s — bare names, `type`-prefixed names, and
+ * `as`-aliased names are all supported.
+ *
+ * @param importInput - The import shorthand (e.g. `'Foo'`, `'type Foo'`,
+ * `'Foo as Bar'`).
+ * @param module - The module the identifier comes from.
+ * @return A frozen {@link Fragment} ready to be interpolated into other
+ * fragments.
+ *
+ * @example
+ * ```ts
+ * import { use } from '@codama/fragments/javascript';
+ *
+ * use('PdaLinkNode', '../linkNodes/PdaLinkNode');
+ * // → content: 'PdaLinkNode'
+ * //   imports: { '../linkNodes/PdaLinkNode' → PdaLinkNode (value) }
+ *
+ * use('type Foo as Bar', './foo');
+ * // → content: 'Bar'
+ * //   imports: { './foo' → Foo as Bar (type-only) }
+ * ```
+ */
+export declare function use(importInput: ImportInput, module: Module): Fragment;
+/**
+ * Append imports to an existing fragment's import map. The fragment's
+ * content and any other fields are preserved.
+ *
+ * @param fragment - The source fragment.
+ * @param module - The module the new imports come from.
+ * @param imports - The import shorthand strings to add.
+ * @return A new frozen fragment with the extended import map.
+ *
+ * @example
+ * ```ts
+ * import { addFragmentImports, fragment } from '@codama/fragments/javascript';
+ *
+ * const f = addFragmentImports(fragment`hello`, './foo', ['Foo']);
+ * ```
+ */
+export declare function addFragmentImports(fragment: Fragment, module: Module, imports: ImportInput[]): Fragment;
+/**
+ * Merge additional import maps into an existing fragment's import map. The
+ * fragment's content and any other fields are preserved.
+ *
+ * @param fragment - The source fragment.
+ * @param importMaps - The additional maps to merge in.
+ * @return A new frozen fragment with the merged import map.
+ */
+export declare function mergeFragmentImports(fragment: Fragment, importMaps: readonly ImportMap[]): Fragment;
+/**
+ * Drop identifiers from a fragment's import map. The fragment's content and
+ * any other fields are preserved.
+ *
+ * @param fragment - The source fragment.
+ * @param module - The module to remove identifiers from.
+ * @param usedIdentifiers - The used-identifier names to drop.
+ * @return A new frozen fragment with the trimmed import map.
+ */
+export declare function removeFragmentImports(fragment: Fragment, module: Module, usedIdentifiers: UsedIdentifier[]): Fragment;
+//# sourceMappingURL=fragment.d.ts.map

package/dist/types/javascript/fragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment.d.ts","sourceRoot":"","sources":["../../../src/javascript/fragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlF;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,QAAQ,CAEtF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,EAAE,EAC5C,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,MAAM,GAC7C,QAAQ,CAMV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAItE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,QAAQ,CAKvG;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,QAAQ,CAKnG;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,EAAE,GAAG,QAAQ,CAKrH"}

package/dist/types/javascript/getDocblockFragment.d.ts

@@ -0,0 +1,53 @@
+import type { Fragment } from './fragment';
+/**
+ * Build a JSDoc-style docblock fragment from an array of lines.
+ *
+ * Empty or `undefined` input returns `undefined` so the helper composes
+ * naturally with the {@link fragment} tag's optional-interpolation
+ * behavior — a node's `docs` attribute can be threaded straight in
+ * without a ternary guard:
+ *
+ * ```ts
+ * fragment`${getDocblockFragment(node.docs)}\nexport interface X {}`;
+ * ```
+ *
+ * Single-line input renders as a one-line block (`/** line *\/`);
+ * multi-line input renders as a standard multi-line JSDoc block. Empty
+ * elements in the array render as bare ` *` lines, useful for paragraph
+ * breaks inside a docblock.
+ *
+ * The helper defangs any literal `*\/` sequences inside the lines (they are
+ * rewritten as `*\\/`) so that user-supplied content cannot accidentally
+ * close the docblock early.
+ *
+ * @param lines - The lines of the docblock, or `undefined`. Empty array
+ * and `undefined` both return `undefined`.
+ * @param options - Optional settings.
+ * @param options.withLineJump - When `true`, appends a trailing `\n` after
+ * the closing `*\/`. Useful when the docblock is followed by a same-line
+ * item like an enum variant.
+ * @return A {@link Fragment} carrying the rendered docblock, or `undefined`
+ * when `lines` is empty or `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { getDocblockFragment } from '@codama/fragments/javascript';
+ *
+ * getDocblockFragment(['Greets the user.'])?.content;
+ * // /** Greets the user. *\/
+ *
+ * getDocblockFragment(['First line.', '', 'Second paragraph.'])?.content;
+ * // /**
+ * //  * First line.
+ * //  *
+ * //  * Second paragraph.
+ * //  *\/
+ *
+ * getDocblockFragment(undefined);
+ * // undefined
+ * ```
+ */
+export declare function getDocblockFragment(lines: readonly string[] | undefined, options?: {
+    withLineJump?: boolean;
+}): Fragment | undefined;
+//# sourceMappingURL=getDocblockFragment.d.ts.map

package/dist/types/javascript/getDocblockFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDocblockFragment.d.ts","sourceRoot":"","sources":["../../../src/javascript/getDocblockFragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACpC,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACzC,QAAQ,GAAG,SAAS,CAOtB"}

package/dist/types/javascript/getExportAllFragment.d.ts

@@ -0,0 +1,21 @@
+import type { Fragment } from './fragment';
+/**
+ * Build a fragment that re-exports every binding from a module:
+ * `export * from '<module>';`.
+ *
+ * The fragment carries no imports — `export * from` only forwards bindings
+ * out, it does not bring `module` into local scope.
+ *
+ * @param module - The module specifier being re-exported.
+ * @return A {@link Fragment} whose content is `export * from '<module>';`.
+ *
+ * @example
+ * ```ts
+ * import { getExportAllFragment } from '@codama/fragments/javascript';
+ *
+ * getExportAllFragment('./accounts').content;
+ * // export * from './accounts';
+ * ```
+ */
+export declare function getExportAllFragment(module: string): Fragment;
+//# sourceMappingURL=getExportAllFragment.d.ts.map

package/dist/types/javascript/getExportAllFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExportAllFragment.d.ts","sourceRoot":"","sources":["../../../src/javascript/getExportAllFragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAE7D"}

package/dist/types/javascript/getExternalDependencies.d.ts

@@ -0,0 +1,29 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Compute the set of external (non-relative) module specifiers an import
+ * map references, with dependency-map resolution applied first. The
+ * returned values are *root* package names — for `'@scope/pkg/sub'` the
+ * value is `'@scope/pkg'`, and for `'pkg/sub'` it is `'pkg'`.
+ *
+ * Useful for syncing a renderer's generated `package.json` from the
+ * imports it ends up emitting.
+ *
+ * @param importMap - The import map to inspect.
+ * @param dependencies - The dependency map to apply before extracting
+ * names. Defaults to no resolution.
+ * @return A {@link Set} of external root package names.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, getExternalDependencies } from '@codama/fragments/javascript';
+ *
+ * let map = createImportMap();
+ * map = addToImportMap(map, '@solana/kit', ['Address']);
+ * map = addToImportMap(map, '@solana/kit/program-client-core', ['ProgramClient']);
+ * map = addToImportMap(map, '../shared', ['Local']);
+ * getExternalDependencies(map);
+ * // → Set { '@solana/kit' }
+ * ```
+ */
+export declare function getExternalDependencies(importMap: ImportMap, dependencies?: Record<string, string>): Set<string>;
+//# sourceMappingURL=getExternalDependencies.d.ts.map

package/dist/types/javascript/getExternalDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExternalDependencies.d.ts","sourceRoot":"","sources":["../../../src/javascript/getExternalDependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAUpH"}

package/dist/types/javascript/importMapToString.d.ts

@@ -0,0 +1,40 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Render an import map as a block of TypeScript `import { … } from '…';`
+ * statements.
+ *
+ * The map is first resolved against `dependencies` so symbolic module
+ * names (e.g. `'solanaAddresses'`, `'generatedAccounts'`) expand to real
+ * specifiers; renderers that don't use symbolic names can omit the
+ * argument.
+ *
+ * Output rules:
+ *   - Modules are sorted with non-relative paths first, then relative;
+ *     within each group, alphabetical.
+ *   - Identifiers within each module are alphabetical.
+ *   - When every import from a given module is type-only, the line is
+ *     emitted as `import type { … } from '…';` rather than per-identifier
+ *     `type` — matching the `@solana/eslint-config-solana`
+ *     consolidate-type-imports convention used across the Codama
+ *     published surface.
+ *
+ * @param importMap - The import map to render.
+ * @param dependencies - The dependency map to apply before rendering.
+ * Defaults to no resolution.
+ * @return The block of import lines, or the empty string if the map is
+ * empty.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, importMapToString } from '@codama/fragments/javascript';
+ *
+ * let map = createImportMap();
+ * map = addToImportMap(map, '@codama/spec', ['type Spec']);
+ * map = addToImportMap(map, '../shared', ['CamelCaseString']);
+ * importMapToString(map);
+ * // import type { Spec } from '@codama/spec';
+ * // import { CamelCaseString } from '../shared';
+ * ```
+ */
+export declare function importMapToString(importMap: ImportMap, dependencies?: Record<string, string>): string;
+//# sourceMappingURL=importMapToString.d.ts.map

package/dist/types/javascript/importMapToString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importMapToString.d.ts","sourceRoot":"","sources":["../../../src/javascript/importMapToString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,aAAa,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,MAAM,CAoBzG"}

package/dist/types/javascript/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@codama/fragments/javascript`
+ *
+ * The JavaScript / TypeScript flavor of the fragment library: a concrete
+ * `Fragment` type carrying a symbolic `ImportMap`, a `fragment` tagged
+ * template that propagates imports through interpolation, and helpers
+ * for building, merging, resolving, and rendering imports.
+ *
+ * Re-exports the language-agnostic core too, so consumers only need a
+ * single import in the typical case.
+ */
+export * from '../core';
+export * from './ImportMap';
+export * from './addToImportMap';
+export * from './mergeImportMaps';
+export * from './removeFromImportMap';
+export * from './resolveImportMap';
+export * from './getExternalDependencies';
+export * from './importMapToString';
+export * from './fragment';
+export * from './getDocblockFragment';
+export * from './getExportAllFragment';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/javascript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/javascript/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}