@codama/fragments 0.1.0

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

@@ -0,0 +1,34 @@
+import type { ImportInfo, ImportMap } from './ImportMap';
+/**
+ * Merge multiple import maps into one. Modules and identifiers from later
+ * maps are layered over earlier ones; collisions on the same `usedIdentifier`
+ * are resolved by {@link preferIncoming}.
+ *
+ * The merge is a pure function: input maps are not mutated. The returned map
+ * is frozen.
+ *
+ * @param importMaps - The import maps to merge, in priority order.
+ * @return A frozen import map that contains every entry from every input.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, mergeImportMaps } from '@codama/fragments/javascript';
+ *
+ * const a = addToImportMap(createImportMap(), './foo', ['Foo']);
+ * const b = addToImportMap(createImportMap(), './bar', ['Bar']);
+ * const merged = mergeImportMaps([a, b]);
+ * ```
+ */
+export declare function mergeImportMaps(importMaps: readonly ImportMap[]): ImportMap;
+/**
+ * Decide whether an incoming `ImportInfo` should replace an existing entry
+ * for the same `usedIdentifier`.
+ *
+ * The single rule we apply: if both refer to the same source identifier and
+ * one is type-only while the other is a value import, the value import wins.
+ * In every other "tied" case the existing entry stays. This keeps a value
+ * import from being silently downgraded to type-only when both are
+ * encountered.
+ */
+export declare function preferIncoming(existing: ImportInfo | undefined, incoming: ImportInfo): boolean;
+//# sourceMappingURL=mergeImportMaps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeImportMaps.d.ts","sourceRoot":"","sources":["../../../src/javascript/mergeImportMaps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAA0B,MAAM,aAAa,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAmB3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,GAAG,SAAS,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAG9F"}

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

@@ -0,0 +1,21 @@
+import type { ImportMap, Module, UsedIdentifier } from './ImportMap';
+/**
+ * Remove identifiers from a module entry. If the module ends up with no
+ * remaining identifiers, the module entry itself is dropped from the map.
+ *
+ * @param importMap - The import map to modify.
+ * @param module - The source module to remove identifiers from.
+ * @param usedIdentifiers - The used-identifier names to drop. Names that
+ * aren't present in the module entry are silently ignored.
+ * @return A new frozen import map without those identifiers.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, removeFromImportMap } from '@codama/fragments/javascript';
+ *
+ * let map = addToImportMap(createImportMap(), './foo', ['Foo', 'Bar']);
+ * map = removeFromImportMap(map, './foo', ['Foo']);
+ * ```
+ */
+export declare function removeFromImportMap(importMap: ImportMap, module: Module, usedIdentifiers: UsedIdentifier[]): ImportMap;
+//# sourceMappingURL=removeFromImportMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"removeFromImportMap.d.ts","sourceRoot":"","sources":["../../../src/javascript/removeFromImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,cAAc,EAAE,GAClC,SAAS,CAUX"}

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

@@ -0,0 +1,33 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Rewrite a JavaScript import map's module keys against a dependency map.
+ *
+ * Resolution is by exact module-name lookup: a module key `'solanaAddresses'`
+ * against `{ solanaAddresses: '@solana/kit' }` becomes `'@solana/kit'`.
+ * Keys that aren't present in `dependencies` are kept unchanged. The
+ * inner `UsedIdentifier → ImportInfo` map for each module is preserved
+ * exactly. When two source modules resolve to the same target, their
+ * inner maps are merged via {@link mergeImportMaps}.
+ *
+ * Renderers typically pre-define a base set of symbolic modules
+ * (`solanaAddresses → @solana/kit`, `generated → ..`, etc.) and pass
+ * them through this function just before calling
+ * {@link importMapToString} or {@link getExternalDependencies}.
+ *
+ * @param importMap - The import map to resolve.
+ * @param dependencies - A record mapping symbolic module names to
+ * resolved module specifiers.
+ * @return A new frozen import map with all module keys resolved.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, resolveImportMap } from '@codama/fragments/javascript';
+ *
+ * let map = createImportMap();
+ * map = addToImportMap(map, 'solanaAddresses', ['Address']);
+ * const resolved = resolveImportMap(map, { solanaAddresses: '@solana/kit' });
+ * // resolved keys: ['@solana/kit']
+ * ```
+ */
+export declare function resolveImportMap(importMap: ImportMap, dependencies: Record<string, string>): ImportMap;
+//# sourceMappingURL=resolveImportMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveImportMap.d.ts","sourceRoot":"","sources":["../../../src/javascript/resolveImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,SAAS,EAA0B,MAAM,aAAa,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAStG"}

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

@@ -0,0 +1,52 @@
+/**
+ * Rust crate keywords that should never be reported as external dependencies.
+ *
+ * {@link getExternalDependencies} filters these out when computing the
+ * package's Cargo dependencies from the imports actually used. They
+ * correspond to paths that resolve inside the crate or to the standard
+ * library.
+ */
+export declare const RUST_CORE_IMPORTS: ReadonlySet<string>;
+/**
+ * The fully-qualified Rust path of an imported item — e.g.
+ * `'solana_program::pubkey::Pubkey'` or `'crate::generated::accounts::AccountNode'`.
+ *
+ * Symbolic prefixes (e.g. `'generated::accounts::Foo'`) are accepted too;
+ * they are resolved into concrete paths by {@link resolveImportMap} just
+ * before stringification.
+ */
+export type ImportPath = string;
+/** The local name an imported path is bound to (the right-hand side of `as`). */
+export type Alias = string;
+/** A parsed Rust import. */
+export interface ImportInfo {
+    readonly alias?: Alias;
+    readonly importedPath: ImportPath;
+}
+/**
+ * The data model used by `@codama/fragments/rust` to track imports
+ * symbolically until they are stringified into actual `use foo::Bar;` lines.
+ *
+ * Unlike the JavaScript flavor, Rust's `use` statement always references a
+ * single fully-qualified path. There is no per-module identifier list, so
+ * the map is flat: keyed by the imported path, with optional alias info as
+ * the value.
+ *
+ * The map is frozen and its operations are pure functions (no methods, no
+ * mutation), matching the JavaScript subpath's paradigm.
+ */
+export type ImportMap = ReadonlyMap<ImportPath, ImportInfo>;
+/**
+ * Construct an empty, frozen import map.
+ *
+ * @return A new {@link ImportMap} with no entries.
+ *
+ * @example
+ * ```ts
+ * import { createImportMap } from '@codama/fragments/rust';
+ *
+ * const empty = createImportMap();
+ * ```
+ */
+export declare function createImportMap(): ImportMap;
+//# sourceMappingURL=ImportMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImportMap.d.ts","sourceRoot":"","sources":["../../../src/rust/ImportMap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAQhD,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,iFAAiF;AACjF,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAE3B,4BAA4B;AAC5B,MAAM,WAAW,UAAU;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;CACrC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,IAAI,SAAS,CAE3C"}

package/dist/types/rust/addAliasToImportMap.d.ts

@@ -0,0 +1,24 @@
+import type { Alias, ImportMap, ImportPath } from './ImportMap';
+/**
+ * Record an alias (`use foo::Bar as Baz;`) for an imported path. If the
+ * path isn't yet in the map, it is added; if it's already present, the
+ * alias is set or replaced. The input map is not mutated.
+ *
+ * @param importMap - The import map to extend.
+ * @param path - The full Rust path being aliased (e.g. `'foo::Bar'`).
+ * @param alias - The local name to use (e.g. `'Baz'`).
+ * @return A new frozen import map with the alias recorded.
+ *
+ * @example
+ * ```ts
+ * import { addAliasToImportMap, createImportMap } from '@codama/fragments/rust';
+ *
+ * const map = addAliasToImportMap(
+ *     createImportMap(),
+ *     'solana_program::program_error::ProgramError',
+ *     'ProgError',
+ * );
+ * ```
+ */
+export declare function addAliasToImportMap(importMap: ImportMap, path: ImportPath, alias: Alias): ImportMap;
+//# sourceMappingURL=addAliasToImportMap.d.ts.map

package/dist/types/rust/addAliasToImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addAliasToImportMap.d.ts","sourceRoot":"","sources":["../../../src/rust/addAliasToImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,CAInG"}

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

@@ -0,0 +1,27 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Append imports to an import map, returning a new frozen map. The input
+ * map is not mutated.
+ *
+ * Aliases are not added by this function — call
+ * {@link addAliasToImportMap} separately when the import needs an `as`
+ * clause.
+ *
+ * @param importMap - The import map to extend.
+ * @param paths - The Rust paths to add. May be a single string, an array,
+ * or a {@link Set}. An 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/rust';
+ *
+ * const map = addToImportMap(createImportMap(), [
+ *     'borsh::BorshDeserialize',
+ *     'borsh::BorshSerialize',
+ * ]);
+ * ```
+ */
+export declare function addToImportMap(importMap: ImportMap, paths: ReadonlySet<string> | string | readonly string[]): ImportMap;
+//# sourceMappingURL=addToImportMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addToImportMap.d.ts","sourceRoot":"","sources":["../../../src/rust/addToImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,GACxD,SAAS,CAWX"}

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

@@ -0,0 +1,118 @@
+import type { BaseFragment } from '../core/BaseFragment';
+import type { Alias, ImportMap, ImportPath } from './ImportMap';
+/**
+ * The Rust-flavored fragment shape: {@link BaseFragment} plus a frozen
+ * {@link ImportMap} carrying the `use` paths the content depends on.
+ *
+ * Both the fragment and its import map are immutable. Every operation in
+ * this subpath that returns a fragment produces a new frozen wrapper, so
+ * fragments compose without aliasing risks.
+ */
+export type Fragment = BaseFragment & Readonly<{
+    imports: ImportMap;
+}>;
+/**
+ * Type guard for the Rust-flavored {@link Fragment} shape.
+ *
+ * @param value - The value to test.
+ * @return `true` when `value` is an object carrying both `content` and
+ * `imports` fields.
+ */
+export declare function isFragment(value: unknown): value is Fragment;
+/**
+ * Tagged-template helper for composing Rust-flavored fragments.
+ * Interpolated values may be:
+ *
+ *   - A {@link Fragment} — content is inlined and imports propagate.
+ *   - `undefined` — rendered as the empty string.
+ *   - Anything else — coerced to a string via `String(value)`.
+ *
+ * Rust does not have a `use(input, module)` shorthand because identifiers
+ * can be referenced inline by their full `::`-qualified path; build
+ * content with the tag and attach imports separately via
+ * {@link addFragmentImports}.
+ *
+ * @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 merged content and imports.
+ *
+ * @example
+ * ```ts
+ * import { addFragmentImports, fragment } from '@codama/fragments/rust';
+ *
+ * const body = fragment`pub struct AccountNode { pubkey: Pubkey }`;
+ * const withImports = addFragmentImports(body, ['solana_program::pubkey::Pubkey']);
+ * ```
+ */
+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}.
+ */
+export declare function mergeFragments(fragments: readonly (Fragment | undefined)[], mergeContent: (contents: string[]) => string): 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 paths - The Rust paths to add. May be a single string, an array,
+ * or a {@link Set}.
+ * @return A new frozen fragment with the extended import map.
+ *
+ * @example
+ * ```ts
+ * import { addFragmentImports, fragment } from '@codama/fragments/rust';
+ *
+ * const f = addFragmentImports(fragment`Pubkey`, ['solana_program::pubkey::Pubkey']);
+ * ```
+ */
+export declare function addFragmentImports(fragment: Fragment, paths: ImportPath | ReadonlySet<string> | readonly ImportPath[]): Fragment;
+/**
+ * Record an alias for an imported path on the fragment's import map. If
+ * the path isn't yet imported, it is added; if it's already present, the
+ * alias replaces any existing one. The fragment's content and any other
+ * fields are preserved.
+ *
+ * @param fragment - The source fragment.
+ * @param path - The full Rust path being aliased.
+ * @param alias - The local name to use.
+ * @return A new frozen fragment with the alias recorded.
+ *
+ * @example
+ * ```ts
+ * import { addFragmentImportAlias, fragment } from '@codama/fragments/rust';
+ *
+ * const f = addFragmentImportAlias(
+ *     fragment`ProgError::InvalidArgument`,
+ *     'solana_program::program_error::ProgramError',
+ *     'ProgError',
+ * );
+ * ```
+ */
+export declare function addFragmentImportAlias(fragment: Fragment, path: ImportPath, alias: Alias): 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 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 paths from a fragment's import map. The fragment's content and any
+ * other fields are preserved.
+ *
+ * @param fragment - The source fragment.
+ * @param paths - The Rust paths to remove. May be a single string, an
+ * array, or a {@link Set}.
+ * @return A new frozen fragment with the trimmed import map.
+ */
+export declare function removeFragmentImports(fragment: Fragment, paths: ImportPath | ReadonlySet<string> | readonly ImportPath[]): Fragment;
+//# sourceMappingURL=fragment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fragment.d.ts","sourceRoot":"","sources":["../../../src/rust/fragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIhE;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAEvE;;;;;;GAMG;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;;;;;;;;;GASG;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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,UAAU,EAAE,GAChE,QAAQ,CAKV;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,CAKnG;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,QAAQ,CAKnG;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,UAAU,EAAE,GAChE,QAAQ,CAKV"}

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

@@ -0,0 +1,53 @@
+import type { Fragment } from './fragment';
+/**
+ * Build a Rust doc-comment 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)}\npub struct X;`;
+ * ```
+ *
+ * Each line is prefixed with `///` (outer doc) by default, or `//!`
+ * (inner doc) when `internal` is `true`. Empty elements in the array
+ * render as a bare prefix line (`///` or `//!` with no trailing space),
+ * useful for paragraph breaks inside a doc comment.
+ *
+ * @param lines - The lines of the doc comment, or `undefined`. Empty
+ * array and `undefined` both return `undefined`.
+ * @param options - Optional settings.
+ * @param options.internal - When `true`, emit inner doc comments (`//!`)
+ * instead of outer doc comments (`///`). Useful for module- or crate-level
+ * documentation.
+ * @param options.withLineJump - When `true`, appends a trailing `\n` after
+ * the last line.
+ * @return A {@link Fragment} carrying the rendered doc comment, or
+ * `undefined` when `lines` is empty or `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { getDocblockFragment } from '@codama/fragments/rust';
+ *
+ * getDocblockFragment(['Greets the user.'])?.content;
+ * // /// Greets the user.
+ *
+ * getDocblockFragment(['First line.', '', 'Second paragraph.'])?.content;
+ * // /// First line.
+ * // ///
+ * // /// Second paragraph.
+ *
+ * getDocblockFragment(['Module docs.'], { internal: true })?.content;
+ * // //! Module docs.
+ *
+ * getDocblockFragment(undefined);
+ * // undefined
+ * ```
+ */
+export declare function getDocblockFragment(lines: readonly string[] | undefined, options?: {
+    internal?: boolean;
+    withLineJump?: boolean;
+}): Fragment | undefined;
+//# sourceMappingURL=getDocblockFragment.d.ts.map

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

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

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

@@ -0,0 +1,30 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Compute the top-level crate names actually imported, with
+ * {@link RUST_CORE_IMPORTS} excluded. Useful for syncing a renderer's
+ * generated `Cargo.toml` from the imports it ends up emitting.
+ *
+ * Imports are first resolved against the dependency map (so symbolic
+ * prefixes like `'generated::…'` are expanded before crate names are
+ * extracted), then the leading `::` segment of each path is collected.
+ *
+ * @param importMap - The import map to inspect.
+ * @param dependencies - The dependency map to apply before extracting
+ * crate names. Defaults to no resolution.
+ * @return A {@link Set} of external crate names.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, getExternalDependencies } from '@codama/fragments/rust';
+ *
+ * const map = addToImportMap(createImportMap(), [
+ *     'borsh::BorshSerialize',
+ *     'std::collections::HashMap',
+ *     'generated::accounts::A',
+ * ]);
+ * getExternalDependencies(map, { generated: 'crate::generated' });
+ * // → Set { 'borsh' }
+ * ```
+ */
+export declare function getExternalDependencies(importMap: ImportMap, dependencies?: Record<string, string>): Set<string>;
+//# sourceMappingURL=getExternalDependencies.d.ts.map

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

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

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

@@ -0,0 +1,30 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Render an import map as a block of `use foo::Bar;` (and `use foo::Bar as Baz;`)
+ * statements.
+ *
+ * The map is first resolved against `dependencies` so symbolic prefixes
+ * like `'generated::…'` expand to concrete crate paths. The output is
+ * sorted alphabetically by path for stable, reviewable diffs.
+ *
+ * @param importMap - The import map to render.
+ * @param dependencies - The dependency map to apply before rendering.
+ * Defaults to no resolution.
+ * @return The block of `use` statements joined by newlines, or the empty
+ * string if the map is empty.
+ *
+ * @example
+ * ```ts
+ * import { addAliasToImportMap, addToImportMap, createImportMap, importMapToString } from '@codama/fragments/rust';
+ *
+ * let map = createImportMap();
+ * map = addToImportMap(map, ['borsh::BorshSerialize', 'solana_program::pubkey::Pubkey']);
+ * map = addAliasToImportMap(map, 'solana_program::program_error::ProgramError', 'ProgError');
+ * importMapToString(map);
+ * // use borsh::BorshSerialize;
+ * // use solana_program::program_error::ProgramError as ProgError;
+ * // use solana_program::pubkey::Pubkey;
+ * ```
+ */
+export declare function importMapToString(importMap: ImportMap, dependencies?: Record<string, string>): string;
+//# sourceMappingURL=importMapToString.d.ts.map

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

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

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

@@ -0,0 +1,23 @@
+/**
+ * `@codama/fragments/rust`
+ *
+ * The Rust flavor of the fragment library: a concrete `Fragment` type
+ * carrying a frozen, functional `ImportMap`, a `fragment` tagged template
+ * that propagates imports through interpolation, and helpers for
+ * building, merging, resolving, and rendering.
+ *
+ * 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 './addAliasToImportMap';
+export * from './mergeImportMaps';
+export * from './removeFromImportMap';
+export * from './resolveImportMap';
+export * from './getExternalDependencies';
+export * from './importMapToString';
+export * from './fragment';
+export * from './getDocblockFragment';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rust/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,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"}

package/dist/types/rust/mergeImportMaps.d.ts

@@ -0,0 +1,23 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Merge multiple import maps into one. Paths from later maps are layered
+ * over earlier ones; if the same path appears in multiple maps, the
+ * latest occurrence's alias info wins.
+ *
+ * The merge is a pure function: input maps are not mutated. The returned
+ * map is frozen.
+ *
+ * @param importMaps - The import maps to merge, in priority order.
+ * @return A frozen import map containing every entry from every input.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, mergeImportMaps } from '@codama/fragments/rust';
+ *
+ * const a = addToImportMap(createImportMap(), ['borsh::BorshDeserialize']);
+ * const b = addToImportMap(createImportMap(), ['solana_program::pubkey::Pubkey']);
+ * const merged = mergeImportMaps([a, b]);
+ * ```
+ */
+export declare function mergeImportMaps(importMaps: readonly ImportMap[]): ImportMap;
+//# sourceMappingURL=mergeImportMaps.d.ts.map

package/dist/types/rust/mergeImportMaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeImportMaps.d.ts","sourceRoot":"","sources":["../../../src/rust/mergeImportMaps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAU3E"}

package/dist/types/rust/removeFromImportMap.d.ts

@@ -0,0 +1,20 @@
+import type { ImportMap, ImportPath } from './ImportMap';
+/**
+ * Drop one or more imported paths from an import map. Paths that aren't
+ * present are silently ignored. The input map is not mutated.
+ *
+ * @param importMap - The import map to trim.
+ * @param paths - The Rust paths to remove. May be a single string, an
+ * array, or a {@link Set}.
+ * @return A new frozen import map without those entries.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, removeFromImportMap } from '@codama/fragments/rust';
+ *
+ * let map = addToImportMap(createImportMap(), ['foo::A', 'foo::B']);
+ * map = removeFromImportMap(map, 'foo::A');
+ * ```
+ */
+export declare function removeFromImportMap(importMap: ImportMap, paths: ImportPath | ReadonlySet<string> | readonly ImportPath[]): ImportMap;
+//# sourceMappingURL=removeFromImportMap.d.ts.map

package/dist/types/rust/removeFromImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeFromImportMap.d.ts","sourceRoot":"","sources":["../../../src/rust/removeFromImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,UAAU,EAAE,GAChE,SAAS,CAMX"}

package/dist/types/rust/resolveImportMap.d.ts

@@ -0,0 +1,32 @@
+import type { ImportMap } from './ImportMap';
+/**
+ * Rewrite the symbolic prefixes of an import map's paths against a
+ * dependency map.
+ *
+ * Resolution is by prefix match on the `::` separator: an import
+ * `'generated::accounts::AccountNode'` against
+ * `{ generated: 'crate::generated' }` becomes
+ * `'crate::generated::accounts::AccountNode'`. Paths that don't match any
+ * prefix are kept unchanged. Aliases follow their path.
+ *
+ * Renderers typically pre-define a base set of symbolic modules
+ * (`generated → crate::generated`, `mplToolbox → mpl_toolbox`, etc.) and
+ * pass them through this function just before calling
+ * {@link importMapToString} or {@link getExternalDependencies}.
+ *
+ * @param importMap - The import map to resolve.
+ * @param dependencies - A record mapping symbolic prefixes to resolved
+ * Rust paths.
+ * @return A new frozen import map with all paths resolved.
+ *
+ * @example
+ * ```ts
+ * import { addToImportMap, createImportMap, resolveImportMap } from '@codama/fragments/rust';
+ *
+ * const map = addToImportMap(createImportMap(), 'generated::accounts::AccountNode');
+ * const resolved = resolveImportMap(map, { generated: 'crate::generated' });
+ * // resolved has 'crate::generated::accounts::AccountNode'
+ * ```
+ */
+export declare function resolveImportMap(importMap: ImportMap, dependencies: Record<string, string>): ImportMap;
+//# sourceMappingURL=resolveImportMap.d.ts.map

package/dist/types/rust/resolveImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveImportMap.d.ts","sourceRoot":"","sources":["../../../src/rust/resolveImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAatG"}