@fuzdev/fuz_ui 0.169.0

package/dist/docs_helpers.svelte.js

@@ -0,0 +1,99 @@
+import { resolve } from '$app/paths';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+import { ensure_end, ensure_start } from '@fuzdev/fuz_util/string.js';
+import { create_context } from './context_helpers.js';
+/**
+ * Convert a string to a URL-safe fragment identifier, preserving case for API declarations.
+ * Only transforms spaces and special characters, keeping valid identifier characters intact.
+ * Used for hash anchors in documentation.
+ * @param str - The string to convert to a fragment
+ * @returns A URL-safe fragment identifier
+ */
+export const docs_slugify = (str) => {
+    return (str
+        .trim()
+        // Replace spaces and multiple hyphens with single hyphen
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        // Remove invalid characters (keep letters, digits, _, $, -)
+        .replace(/[^\w$-]/g, '')
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, ''));
+};
+export const DOCS_PATH_DEFAULT = '/docs';
+export const DOCS_PATH = resolve('/docs');
+export const DOCS_API_PATH = DOCS_PATH + '/api';
+export const to_docs_path_info = (path_slug, pathname, root_path = DOCS_PATH_DEFAULT) => {
+    const path_segment = pathname.split('/').at(-1);
+    const path = resolve((ensure_end(ensure_start(root_path, '/'), '/') + path_slug));
+    const path_is_selected = path_segment === path_slug; // messy but works
+    return { path, path_is_selected, path_segment };
+};
+export const docs_links_context = create_context();
+export class DocsLinks {
+    root_path;
+    links = new SvelteMap();
+    // Maps compound keys (pathname#fragment) to their original order
+    // This preserves order across component remounts
+    #fragment_to_order = new Map();
+    // Counter for generating unique IDs
+    #next_id = 0;
+    // Counter for generating section IDs (page-scoped, not module-scoped)
+    #section_counter = 0;
+    // Counter for generating link order values (page-scoped, not module-scoped)
+    // This ensures consistent ordering between SSR and client hydration
+    #order_counter = 0;
+    docs_links = $derived.by(() => {
+        // Build parent-child map
+        const children_map = new Map();
+        for (const link of this.links.values()) {
+            if (!children_map.has(link.parent_id)) {
+                children_map.set(link.parent_id, []);
+            }
+            children_map.get(link.parent_id).push(link);
+        }
+        // Sort siblings by order
+        for (const siblings of children_map.values()) {
+            siblings.sort((a, b) => a.order - b.order);
+        }
+        // Flatten tree with depth-first traversal
+        const result = [];
+        const traverse = (parent_id) => {
+            const children = children_map.get(parent_id) || [];
+            for (const child of children) {
+                result.push(child);
+                traverse(child.id); // recursively add children
+            }
+        };
+        traverse(undefined); // start with root nodes (no parent)
+        return result;
+    });
+    fragments_onscreen = new SvelteSet();
+    constructor(root_path = DOCS_PATH_DEFAULT) {
+        this.root_path = root_path;
+    }
+    add(fragment, text, pathname, tag, depth = 1, parent_id, explicit_id) {
+        // Use explicit ID if provided, otherwise generate one
+        const id = explicit_id ?? 'docs_link_' + this.#next_id++;
+        // Use compound key (pathname#fragment) to preserve order across remounts
+        const page_fragment_key = `${pathname}#${fragment}`;
+        const existing_order = this.#fragment_to_order.get(page_fragment_key);
+        const order = existing_order ?? this.#order_counter++;
+        // Store order for new fragments only
+        if (existing_order === undefined) {
+            this.#fragment_to_order.set(page_fragment_key, order);
+        }
+        this.links.set(id, { id, fragment, text, tag, depth, order, parent_id });
+        return id;
+    }
+    remove(id) {
+        this.links.delete(id);
+    }
+    /**
+     * Generate a unique section ID for the current page render.
+     * This counter is instance-scoped, ensuring SSR/client consistency.
+     */
+    generate_section_id() {
+        return `section_${this.#section_counter++}`;
+    }
+}

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const render_value_to_string: (value: unknown) => string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/helpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,GAAI,OAAO,OAAO,KAAG,MASvD,CAAC"}

package/dist/helpers.js

@@ -0,0 +1,16 @@
+export const render_value_to_string = (value) => {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    const type = typeof value;
+    if (type === 'string')
+        return `'${value}'`; // eslint-disable-line @typescript-eslint/no-base-to-string
+    if (type === 'number' || type === 'boolean')
+        return value + ''; // eslint-disable-line @typescript-eslint/no-base-to-string
+    if (Array.isArray(value))
+        return `[${value.map(render_value_to_string).join(', ')}]`;
+    if (type === 'object')
+        return JSON.stringify(value);
+    return value + ''; // eslint-disable-line @typescript-eslint/no-base-to-string
+};

package/dist/intersect.svelte.d.ts

@@ -0,0 +1,47 @@
+import type { Attachment } from 'svelte/attachments';
+export interface IntersectParams {
+    /**
+     * Called when the element enters or leaves the viewport until disconnected.
+     */
+    onintersect?: OnIntersect;
+    /**
+     * Called when the attachment's observer is disconnected,
+     * either by the user calling disconnect or the attachment being destroyed.
+     */
+    ondisconnect?: OnDisconnect;
+    /**
+     * A value of `1` disconnects after `el` enters and leaves the viewport one time,
+     * similar to 'once' for an event.
+     * `0` disables and `undefined` or a negative number like `-1` never disconnects.
+     */
+    count?: number;
+    /**
+     * Same as the `options` param to
+     * [`IntersectionObserver`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver/IntersectionObserver#options)
+     */
+    options?: IntersectionObserverInit;
+}
+export type IntersectParamsOrCallback = OnIntersect | IntersectParams;
+/**
+ * Creates an attachment that observes element viewport intersection.
+ * Uses the lazy function pattern to optimize reactivity:
+ * callbacks can update without recreating the observer, preserving state.
+ * @param get_params Function that returns callback, params object, or nullish to disable
+ */
+export declare const intersect: (get_params: () => IntersectParamsOrCallback | null | undefined) => Attachment<HTMLElement | SVGElement>;
+export type OnIntersect = (state: IntersectState) => void;
+export interface IntersectState {
+    intersecting: boolean;
+    intersections: number;
+    el: HTMLElement | SVGElement;
+    observer: IntersectionObserver;
+    disconnect: () => void;
+}
+export type OnDisconnect = (state: DisconnectState) => void;
+export interface DisconnectState {
+    intersecting: boolean;
+    intersections: number;
+    el: HTMLElement | SVGElement;
+    observer: IntersectionObserver;
+}
+//# sourceMappingURL=intersect.svelte.d.ts.map

package/dist/intersect.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersect.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/intersect.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAGnD,MAAM,WAAW,eAAe;IAC/B;;OAEG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACnC;AAED,MAAM,MAAM,yBAAyB,GAAG,WAAW,GAAG,eAAe,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAEpB,YAAY,MAAM,yBAAyB,GAAG,IAAI,GAAG,SAAS,KAC5D,UAAU,CAAC,WAAW,GAAG,UAAU,CA6FrC,CAAC;AAGH,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC9B,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,WAAW,GAAG,UAAU,CAAC;IAC7B,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB;AAGD,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC/B,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,WAAW,GAAG,UAAU,CAAC;IAC7B,QAAQ,EAAE,oBAAoB,CAAC;CAC/B"}

package/dist/intersect.svelte.js

@@ -0,0 +1,92 @@
+import { deep_equal } from '@fuzdev/fuz_util/deep_equal.js';
+/**
+ * Creates an attachment that observes element viewport intersection.
+ * Uses the lazy function pattern to optimize reactivity:
+ * callbacks can update without recreating the observer, preserving state.
+ * @param get_params Function that returns callback, params object, or nullish to disable
+ */
+export const intersect = (get_params) => (el) => {
+    // State that persists across callback changes
+    let intersecting = false;
+    let intersections = 0;
+    let observer = null;
+    let current_options = undefined;
+    // Current callbacks - updated reactively without recreating observer
+    let current_onintersect;
+    let current_ondisconnect;
+    let current_count;
+    const disconnect = () => {
+        if (!observer)
+            return;
+        const observer_to_disconnect = observer;
+        observer.disconnect();
+        if (current_ondisconnect) {
+            current_ondisconnect({ intersecting, intersections, el, observer: observer_to_disconnect });
+        }
+        observer = null;
+    };
+    $effect(() => {
+        const params = get_params();
+        if (params == null) {
+            // Params disabled, disconnect if active
+            current_onintersect = undefined;
+            current_ondisconnect = undefined;
+            current_count = undefined;
+            if (observer) {
+                disconnect();
+            }
+            return;
+        }
+        // Parse params and update current callbacks
+        let options;
+        if (typeof params === 'function') {
+            current_onintersect = params;
+            current_ondisconnect = undefined;
+            current_count = undefined;
+            options = undefined;
+        }
+        else {
+            current_onintersect = params.onintersect;
+            current_ondisconnect = params.ondisconnect;
+            current_count = params.count;
+            options = params.options;
+        }
+        // Check if count is 0 (disabled)
+        if (current_count === 0) {
+            if (observer) {
+                disconnect();
+            }
+            return;
+        }
+        // Check if options changed (requires observer recreation)
+        const options_changed = !deep_equal(current_options, options);
+        if (options_changed || !observer) {
+            // Disconnect old observer if exists
+            if (observer) {
+                disconnect();
+            }
+            // Reset state on observer recreation
+            intersecting = false;
+            intersections = 0;
+            current_options = options;
+            // Create new observer
+            observer = new IntersectionObserver((entries) => {
+                intersecting = entries[0].isIntersecting;
+                if (current_onintersect && observer) {
+                    current_onintersect({ intersecting, intersections, el, observer, disconnect });
+                }
+                if (intersecting) {
+                    intersections++;
+                }
+                else {
+                    if (current_count && current_count > 0 && intersections >= current_count) {
+                        disconnect();
+                    }
+                }
+            }, options);
+            observer.observe(el);
+        }
+        // If only callbacks changed, observer stays alive and uses new callbacks from closure
+    });
+    return disconnect;
+};

package/dist/library.svelte.d.ts

@@ -0,0 +1,197 @@
+import type { LibraryJson } from '@fuzdev/fuz_util/library_json.js';
+import { Declaration } from './declaration.svelte.js';
+import { Module } from './module.svelte.js';
+/**
+ * Rich runtime representation of a library.
+ *
+ * Wraps `LibraryJson` with computed properties and provides the root
+ * of the API documentation hierarchy: Library → modules → declarations
+ *
+ * @see module.svelte.ts for Module class
+ * @see declaration.svelte.ts for Declaration class
+ */
+export declare class Library {
+    readonly library_json: LibraryJson;
+    package_json: {
+        [x: string]: unknown;
+        name: string;
+        version: string;
+        private?: boolean | undefined;
+        public?: boolean | undefined;
+        description?: string | undefined;
+        motto?: string | undefined;
+        glyph?: string | undefined;
+        logo?: string | undefined;
+        logo_alt?: string | undefined;
+        license?: string | undefined;
+        scripts?: Record<string, string> | undefined;
+        homepage?: string | undefined;
+        author?: string | {
+            [x: string]: unknown;
+            name: string;
+            email?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+        repository?: string | {
+            [x: string]: unknown;
+            type: string;
+            url: string;
+            directory?: string | undefined;
+        } | undefined;
+        contributors?: (string | {
+            [x: string]: unknown;
+            name: string;
+            email?: string | undefined;
+            url?: string | undefined;
+        })[] | undefined;
+        bugs?: string | {
+            [x: string]: unknown;
+            url?: string | undefined;
+            email?: string | undefined;
+        } | undefined;
+        funding?: string | {
+            [x: string]: unknown;
+            type: string;
+            url: string;
+        } | (string | {
+            [x: string]: unknown;
+            type: string;
+            url: string;
+        })[] | undefined;
+        keywords?: string[] | undefined;
+        type?: string | undefined;
+        engines?: Record<string, string> | undefined;
+        os?: string[] | undefined;
+        cpu?: string[] | undefined;
+        dependencies?: Record<string, string> | undefined;
+        devDependencies?: Record<string, string> | undefined;
+        peerDependencies?: Record<string, string> | undefined;
+        peerDependenciesMeta?: Record<string, {
+            [x: string]: unknown;
+            optional: boolean;
+        }> | undefined;
+        optionalDependencies?: Record<string, string> | undefined;
+        bin?: Record<string, string> | undefined;
+        sideEffects?: string[] | undefined;
+        files?: string[] | undefined;
+        main?: string | undefined;
+        exports?: string | Record<string, unknown> | null | undefined;
+    };
+    source_json: {
+        [x: string]: unknown;
+        name: string;
+        version: string;
+        modules?: {
+            [x: string]: unknown;
+            path: string;
+            declarations?: {
+                [x: string]: unknown;
+                name: string;
+                kind: "function" | "type" | "json" | "variable" | "class" | "constructor" | "component" | "css";
+                doc_comment?: string | undefined;
+                type_signature?: string | undefined;
+                modifiers?: string[] | undefined;
+                source_line?: number | undefined;
+                parameters?: {
+                    [x: string]: unknown;
+                    name: string;
+                    type: string;
+                    optional?: boolean | undefined;
+                    description?: string | undefined;
+                    default_value?: string | undefined;
+                }[] | undefined;
+                return_type?: string | undefined;
+                return_description?: string | undefined;
+                generic_params?: {
+                    [x: string]: unknown;
+                    name: string;
+                    constraint?: string | undefined;
+                    default_type?: string | undefined;
+                }[] | undefined;
+                examples?: string[] | undefined;
+                deprecated_message?: string | undefined;
+                see_also?: string[] | undefined;
+                throws?: {
+                    [x: string]: unknown;
+                    description: string;
+                    type?: string | undefined;
+                }[] | undefined;
+                since?: string | undefined;
+                extends?: string[] | undefined;
+                implements?: string[] | undefined;
+                members?: Record<string, unknown>[] | undefined;
+                properties?: Record<string, unknown>[] | undefined;
+                props?: {
+                    [x: string]: unknown;
+                    name: string;
+                    type: string;
+                    optional?: boolean | undefined;
+                    description?: string | undefined;
+                    default_value?: string | undefined;
+                    bindable?: boolean | undefined;
+                }[] | undefined;
+                also_exported_from?: string[] | undefined;
+                alias_of?: {
+                    module: string;
+                    name: string;
+                } | undefined;
+            }[] | undefined;
+            module_comment?: string | undefined;
+            dependencies?: string[] | undefined;
+            dependents?: string[] | undefined;
+        }[] | undefined;
+    };
+    name: string;
+    repo_name: string;
+    repo_url: import("@fuzdev/fuz_util/url.js").Url;
+    owner_name: string | null;
+    homepage_url: import("@fuzdev/fuz_util/url.js").Url | null;
+    logo_url: import("@fuzdev/fuz_util/url.js").Url | null;
+    logo_alt: string;
+    npm_url: import("@fuzdev/fuz_util/url.js").Url | null;
+    changelog_url: import("@fuzdev/fuz_util/url.js").Url | null;
+    published: boolean;
+    /**
+     * Organization URL (e.g., 'https://github.com/ryanatkn').
+     */
+    org_url: string | null;
+    /**
+     * All modules as rich Module instances.
+     */
+    modules: Module[];
+    /**
+     * All modules sorted alphabetically by path.
+     */
+    modules_sorted: Module[];
+    /**
+     * All declarations across all modules as a flat array.
+     */
+    declarations: Declaration[];
+    /**
+     * Declaration lookup map by name. Provides O(1) lookup.
+     */
+    declaration_map: Map<string, Declaration>;
+    constructor(library_json: LibraryJson);
+    /**
+     * Look up a declaration by name.
+     */
+    lookup_declaration(name: string): Declaration | undefined;
+    /**
+     * Check if a declaration exists.
+     */
+    has_declaration(name: string): boolean;
+    /**
+     * Look up a module by its canonical path.
+     */
+    lookup_module(path: string): Module | undefined;
+    /**
+     * Search declarations by query string with multi-term AND logic.
+     */
+    search_declarations(query: string): Array<Declaration>;
+}
+export declare const library_context: {
+    get: (error_message?: string) => Library;
+    get_maybe: () => Library | undefined;
+    set: (value: Library) => Library;
+};
+//# sourceMappingURL=library.svelte.d.ts.map

package/dist/library.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/library.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAGlE,OAAO,EAAC,WAAW,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAE1C;;;;;;;;GAQG;AACH,qBAAa,OAAO;IACnB,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAiB;IAEnD,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA4C;IACxD,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA2C;IAEtD,IAAI,SAAoC;IACxC,SAAS,SAAyC;IAClD,QAAQ,wCAAwC;IAChD,UAAU,gBAA0C;IACpD,YAAY,+CAA4C;IACxD,QAAQ,+CAAwC;IAChD,QAAQ,SAAwC;IAChD,OAAO,+CAAuC;IAC9C,aAAa,+CAA6C;IAC1D,SAAS,UAAyC;IAElD;;OAEG;IACH,OAAO,gBAML;IAEF;;OAEG;IACH,OAAO,WAIL;IAEF;;OAEG;IACH,cAAc,WAA4E;IAE1F;;OAEG;IACH,YAAY,gBAAmE;IAE/E;;OAEG;IACH,eAAe,2BAAgE;gBAEnE,YAAY,EAAE,WAAW;IAIrC;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIzD;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAItC;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI/C;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC;CAGtD;AAED,eAAO,MAAM,eAAe;;;;CAA4B,CAAC"}

package/dist/library.svelte.js

@@ -0,0 +1,130 @@
+import { create_context } from './context_helpers.js';
+import { Declaration } from './declaration.svelte.js';
+import { Module } from './module.svelte.js';
+/**
+ * Rich runtime representation of a library.
+ *
+ * Wraps `LibraryJson` with computed properties and provides the root
+ * of the API documentation hierarchy: Library → modules → declarations
+ *
+ * @see module.svelte.ts for Module class
+ * @see declaration.svelte.ts for Declaration class
+ */
+export class Library {
+    library_json = $state.raw();
+    package_json = $derived(this.library_json.package_json);
+    source_json = $derived(this.library_json.source_json);
+    name = $derived(this.library_json.name);
+    repo_name = $derived(this.library_json.repo_name);
+    repo_url = $derived(this.library_json.repo_url);
+    owner_name = $derived(this.library_json.owner_name);
+    homepage_url = $derived(this.library_json.homepage_url);
+    logo_url = $derived(this.library_json.logo_url);
+    logo_alt = $derived(this.library_json.logo_alt);
+    npm_url = $derived(this.library_json.npm_url);
+    changelog_url = $derived(this.library_json.changelog_url);
+    published = $derived(this.library_json.published);
+    /**
+     * Organization URL (e.g., 'https://github.com/ryanatkn').
+     */
+    org_url = $derived(this.repo_url && this.repo_name
+        ? this.repo_url.endsWith('/' + this.repo_name)
+            ? this.repo_url.slice(0, -this.repo_name.length - 1)
+            : null
+        : null);
+    /**
+     * All modules as rich Module instances.
+     */
+    modules = $derived(this.source_json.modules
+        ? this.source_json.modules.map((module_json) => new Module(this, module_json))
+        : []);
+    /**
+     * All modules sorted alphabetically by path.
+     */
+    modules_sorted = $derived([...this.modules].sort((a, b) => a.path.localeCompare(b.path)));
+    /**
+     * All declarations across all modules as a flat array.
+     */
+    declarations = $derived(this.modules.flatMap((module) => module.declarations));
+    /**
+     * Declaration lookup map by name. Provides O(1) lookup.
+     */
+    declaration_map = $derived(new Map(this.declarations.map((d) => [d.name, d])));
+    constructor(library_json) {
+        this.library_json = library_json;
+    }
+    /**
+     * Look up a declaration by name.
+     */
+    lookup_declaration(name) {
+        return this.declaration_map.get(name);
+    }
+    /**
+     * Check if a declaration exists.
+     */
+    has_declaration(name) {
+        return this.declaration_map.has(name);
+    }
+    /**
+     * Look up a module by its canonical path.
+     */
+    lookup_module(path) {
+        return this.modules.find((m) => m.path === path);
+    }
+    /**
+     * Search declarations by query string with multi-term AND logic.
+     */
+    search_declarations(query) {
+        return library_search_declarations(this.declarations, query);
+    }
+}
+export const library_context = create_context();
+/**
+ * Search declarations by query string with multi-term AND logic.
+ */
+const library_search_declarations = (declarations, query) => {
+    if (!query.trim())
+        return [];
+    const terms = query.trim().toLowerCase().split(/\s+/);
+    const results = declarations
+        .map((declaration) => {
+        let total_score = 0;
+        for (const term of terms) {
+            const name_score = library_score_match(declaration.name, term);
+            const kind_score = library_score_match(declaration.kind, term);
+            const module_score = library_score_match(declaration.module_path, term);
+            const term_best = Math.max(name_score, kind_score, module_score);
+            if (term_best === 0) {
+                return null;
+            }
+            total_score += term_best;
+        }
+        return { declaration, score: total_score };
+    })
+        .filter((r) => r !== null)
+        .sort((a, b) => b.score - a.score || a.declaration.name.localeCompare(b.declaration.name))
+        .map((r) => r.declaration);
+    return results;
+};
+/**
+ * Score a search term match against a field value.
+ */
+const library_score_match = (field_value, term) => {
+    const field_lower = field_value.toLowerCase();
+    if (field_lower === term)
+        return 100;
+    if (field_lower.startsWith(term))
+        return 80;
+    if (field_lower.includes(term))
+        return 60;
+    let term_idx = 0;
+    for (const char of field_lower) {
+        if (char === term[term_idx]) {
+            term_idx++;
+            if (term_idx === term.length) {
+                return 40;
+            }
+        }
+    }
+    return 0;
+};

package/dist/library_gen.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Library metadata generator helper.
+ *
+ * Generates package_json and source_json with rich metadata:
+ * - JSDoc/TSDoc comments with full tag support
+ * - Full type signatures
+ * - Source code locations
+ * - Parameter information with descriptions and defaults
+ * - Return value documentation
+ * - Usage examples
+ * - Dependency graphs
+ * - Svelte component props
+ *
+ * @see @fuzdev/fuz_util/source_json.js for type definitions
+ * @see src/lib/library_gen_helpers.ts for buildtime-only helpers
+ * @see src/lib/tsdoc_helpers.ts for JSDoc/TSDoc parsing
+ * @see src/lib/ts_helpers.ts for TypeScript analysis
+ * @see src/lib/svelte_helpers.ts for Svelte component analysis
+ */
+import type { Gen } from '@ryanatkn/gro';
+export interface LibraryGenOptions {
+    filename?: string;
+}
+/**
+ * Creates a Gen object for generating library metadata with full TypeScript analysis.
+ *
+ * Usage in a `.gen.ts` file:
+ * ```ts
+ * import {library_gen} from './library_gen.js';
+ * export const gen = library_gen();
+ * ```
+ */
+export declare const library_gen: (options?: LibraryGenOptions) => Gen;
+//# sourceMappingURL=library_gen.d.ts.map

package/dist/library_gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library_gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/library_gen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,eAAe,CAAC;AAevC,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,iBAAiB,KAAG,GA+GzD,CAAC"}