@fuzdev/gro 0.192.0

package/dist/package_json.js

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+import { join } from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
+import { plural, strip_end } from '@fuzdev/fuz_util/string.js';
+import { styleText as st } from 'node:util';
+import { PackageJson, PackageJsonExports } from '@fuzdev/fuz_util/package_json.js';
+import { fs_search } from '@fuzdev/fuz_util/fs.js';
+import { paths, gro_paths, IS_THIS_GRO } from "./paths.js";
+import { PACKAGE_JSON_FILENAME, SVELTEKIT_DIST_DIRNAME, TS_MATCHER, JS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER, } from "./constants.js";
+import { has_sveltekit_library } from "./sveltekit_helpers.js";
+import { GITHUB_REPO_MATCHER } from "./github.js";
+export const PACKAGE_JSON_EMPTY = { name: '', version: '' };
+export const package_json_load = async (dir = IS_THIS_GRO ? gro_paths.root : paths.root, cache, parse = true, // TODO pass `false` here in more places, especially anything perf-sensitive like work on startup
+log) => {
+    let package_json;
+    if (cache && dir in cache) {
+        return cache[dir];
+    }
+    try {
+        package_json = JSON.parse(await package_json_load_contents(dir));
+    }
+    catch (error) {
+        log?.error(st('yellow', `Failed to load package.json in ${dir}`), error);
+        return PACKAGE_JSON_EMPTY;
+    }
+    if (parse) {
+        package_json = parse_package_json(PackageJson, package_json);
+    }
+    if (cache) {
+        cache[dir] = package_json;
+    }
+    return package_json;
+};
+export const package_json_sync = async (map_package_json, log, write = true, dir = paths.root, exports_dir = paths.lib) => {
+    const exported_files = await fs_search(exports_dir);
+    const exported_paths = exported_files.map((f) => f.path);
+    const updated = await package_json_update(async (package_json) => {
+        if ((await has_sveltekit_library(package_json)).ok) {
+            package_json.exports = package_json_to_exports(exported_paths);
+        }
+        const mapped = await map_package_json(package_json);
+        return mapped ? parse_package_json(PackageJson, mapped) : mapped;
+    }, dir, write);
+    const exports_count = updated.changed && updated.package_json?.exports
+        ? Object.keys(updated.package_json.exports).length
+        : 0;
+    log.info(updated.changed
+        ? `updated package.json exports with ${exports_count} total export${plural(exports_count)}`
+        : 'no changes to exports in package.json');
+    return updated;
+};
+export const package_json_load_for_gro = () => package_json_load(gro_paths.root);
+// TODO probably make this nullable and make callers handle failures
+const package_json_load_contents = (dir) => readFile(join(dir, PACKAGE_JSON_FILENAME), 'utf8');
+export const package_json_write = (serialized_package_json) => writeFile(join(paths.root, PACKAGE_JSON_FILENAME), serialized_package_json);
+export const package_json_serialize = (package_json) => JSON.stringify(parse_package_json(PackageJson, package_json), null, 2) + '\n';
+/**
+ * Updates package.json. Writes to the filesystem only when contents change.
+ */
+export const package_json_update = async (update, dir = paths.root, write = true) => {
+    const original_contents = await package_json_load_contents(dir);
+    const original = JSON.parse(original_contents);
+    const updated = await update(original);
+    if (updated === null) {
+        return { package_json: original, changed: false };
+    }
+    const updated_contents = package_json_serialize(updated);
+    if (updated_contents === original_contents) {
+        return { package_json: original, changed: false };
+    }
+    if (write)
+        await package_json_write(updated_contents);
+    return { package_json: updated, changed: true };
+};
+const is_index = (path) => path === 'index.ts' || path === 'index.js';
+export const package_json_to_exports = (paths) => {
+    const has_index = paths.some(is_index);
+    const has_js = paths.some((p) => TS_MATCHER.test(p) || JS_MATCHER.test(p));
+    const has_svelte = paths.some((p) => SVELTE_MATCHER.test(p));
+    const has_json = paths.some((p) => JSON_MATCHER.test(p));
+    const has_css = paths.some((p) => CSS_MATCHER.test(p));
+    const exports = {
+        './package.json': './package.json',
+    };
+    if (has_index) {
+        exports['.'] = {
+            types: IMPORT_PREFIX + 'index.d.ts',
+            default: IMPORT_PREFIX + 'index.js',
+        };
+    }
+    if (has_js) {
+        exports['./*.js'] = {
+            types: IMPORT_PREFIX + '*.d.ts',
+            default: IMPORT_PREFIX + '*.js',
+        };
+        exports['./*.ts'] = {
+            types: IMPORT_PREFIX + '*.d.ts',
+            default: IMPORT_PREFIX + '*.js',
+        };
+    }
+    if (has_svelte) {
+        exports['./*.svelte'] = {
+            types: IMPORT_PREFIX + '*.svelte.d.ts',
+            svelte: IMPORT_PREFIX + '*.svelte',
+            default: IMPORT_PREFIX + '*.svelte',
+        };
+    }
+    if (has_json) {
+        exports['./*.json'] = {
+            types: IMPORT_PREFIX + '*.json.d.ts',
+            default: IMPORT_PREFIX + '*.json',
+        };
+    }
+    if (has_css) {
+        exports['./*.css'] = {
+            default: IMPORT_PREFIX + '*.css',
+        };
+    }
+    return parse_or_throw_formatted_error('package.json#exports', PackageJsonExports, exports);
+};
+const IMPORT_PREFIX = './' + SVELTEKIT_DIST_DIRNAME + '/';
+export const package_json_parse_repo_url = (package_json) => {
+    const { repository } = package_json;
+    const repo_url = repository
+        ? typeof repository === 'string'
+            ? repository
+            : repository.url
+        : undefined;
+    if (!repo_url) {
+        return;
+    }
+    const parsed_repo_url = GITHUB_REPO_MATCHER.exec(strip_end(strip_end(repo_url, '/'), '.git'));
+    if (!parsed_repo_url) {
+        return;
+    }
+    const [, owner, repo] = parsed_repo_url;
+    return { owner: owner, repo: repo };
+};
+/**
+ * Parses a `PackageJson` object but preserves the order of the original keys.
+ */
+const parse_package_json = (schema, value) => {
+    const parsed = parse_or_throw_formatted_error(PACKAGE_JSON_FILENAME, schema, value);
+    const keys = Object.keys(value);
+    return Object.fromEntries(Object.entries(parsed).sort(([a], [b]) => keys.indexOf(a) - keys.indexOf(b)));
+};
+// TODO maybe extract to zod helpers? see also everything in `task_logging.ts`
+const parse_or_throw_formatted_error = (name, schema, value) => {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        let msg = st('red', `Failed to parse ${name}:\n`);
+        for (const issue of parsed.error.issues) {
+            msg += st('red', `\n\t"${issue.path}" ${issue.message}\n`);
+        }
+        throw Error(msg);
+    }
+    return parsed.data;
+};
+export const package_json_has_dependency = (dep_name, package_json) => !!package_json.devDependencies?.[dep_name] ||
+    !!package_json.dependencies?.[dep_name] ||
+    !!package_json.peerDependencies?.[dep_name];
+export const package_json_extract_dependencies = (package_json) => {
+    const deps_by_name = new Map();
+    // Earlier versions override later ones, so peer deps goes last.
+    const add_deps = (deps) => {
+        if (!deps)
+            return;
+        for (const [name, version] of Object.entries(deps)) {
+            if (!deps_by_name.has(name)) {
+                deps_by_name.set(name, { name, version });
+            }
+        }
+    };
+    add_deps(package_json.dependencies);
+    add_deps(package_json.devDependencies);
+    add_deps(package_json.peerDependencies);
+    return Array.from(deps_by_name.values());
+};

package/dist/parse_exports.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import type { Flavored } from '@fuzdev/fuz_util/types.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { DeclarationKind } from '@fuzdev/fuz_util/source_json.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+export interface Declaration {
+    name: string;
+    kind: DeclarationKind | null;
+}
+export type ExportDeclaration = Flavored<Declaration, 'ExportDeclaration'>;
+/**
+ * Parse exports from a file based on its file type and content.
+ */
+export declare const parse_exports: (id: PathId, program?: ts.Program, declarations?: Array<ExportDeclaration>, log?: Logger) => Array<ExportDeclaration>;
+export declare const infer_declarations_from_file_type: (file_path: PathId, declarations?: Array<ExportDeclaration>) => Array<ExportDeclaration>;
+/**
+ * Process TypeScript exports, identifying their kinds.
+ */
+export declare const process_ts_exports: (source_file: ts.SourceFile, program: ts.Program, exports: Array<ts.Symbol>, declarations?: Array<ExportDeclaration>, log?: Logger) => Array<ExportDeclaration>;
+//# sourceMappingURL=parse_exports.d.ts.map

package/dist/parse_exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_exports.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/parse_exports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAKrD,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,aAAa,GACzB,IAAI,MAAM,EACV,UAAU,EAAE,CAAC,OAAO,EACpB,eAAc,KAAK,CAAC,iBAAiB,CAAM,EAC3C,MAAM,MAAM,KACV,KAAK,CAAC,iBAAiB,CAyBzB,CAAC;AAGF,eAAO,MAAM,iCAAiC,GAC7C,WAAW,MAAM,EACjB,eAAc,KAAK,CAAC,iBAAiB,CAAM,KACzC,KAAK,CAAC,iBAAiB,CA4BzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC9B,aAAa,EAAE,CAAC,UAAU,EAC1B,SAAS,EAAE,CAAC,OAAO,EACnB,SAAS,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,EACzB,eAAc,KAAK,CAAC,iBAAiB,CAAM,EAC3C,MAAM,MAAM,KACV,KAAK,CAAC,iBAAiB,CAIzB,CAAC"}

package/dist/parse_exports.js

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { extname } from 'node:path';
+import { TS_MATCHER } from "./constants.js";
+import { ParseExportsContext } from "./parse_exports_context.js";
+/**
+ * Parse exports from a file based on its file type and content.
+ */
+export const parse_exports = (id, program, declarations = [], log) => {
+    // First, infer declarations based on file extension
+    infer_declarations_from_file_type(id, declarations);
+    // For TypeScript files with program, perform detailed export analysis
+    if (TS_MATCHER.test(id) && program) {
+        const source_file = program.getSourceFile(id);
+        if (!source_file)
+            return declarations;
+        const checker = program.getTypeChecker();
+        // Get the exports of the source file (module)
+        const symbol = checker.getSymbolAtLocation(source_file);
+        if (!symbol)
+            return declarations;
+        // Get the module exports
+        const exports = checker.getExportsOfModule(symbol);
+        // Process TypeScript declarations
+        const export_context = new ParseExportsContext(program, log);
+        export_context.analyze_source_file(source_file);
+        export_context.process_exports(source_file, exports, declarations);
+    }
+    return declarations;
+};
+// TODO temporary until proper type inference
+export const infer_declarations_from_file_type = (file_path, declarations = []) => {
+    const extension = extname(file_path).toLowerCase();
+    switch (extension) {
+        case '.svelte': {
+            declarations.push({
+                name: 'default',
+                kind: 'component',
+            });
+            break;
+        }
+        case '.css': {
+            declarations.push({
+                name: 'default',
+                kind: 'css',
+            });
+            break;
+        }
+        case '.json': {
+            declarations.push({
+                name: 'default',
+                kind: 'json',
+            });
+            break;
+        }
+    }
+    return declarations;
+};
+/**
+ * Process TypeScript exports, identifying their kinds.
+ */
+export const process_ts_exports = (source_file, program, exports, declarations = [], log) => {
+    const export_context = new ParseExportsContext(program, log);
+    export_context.analyze_source_file(source_file);
+    return export_context.process_exports(source_file, exports, declarations);
+};

package/dist/parse_exports_context.d.ts

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { ExportDeclaration } from './parse_exports.ts';
+/**
+ * A class to track export context and determine export kinds.
+ */
+export declare class ParseExportsContext {
+    #private;
+    readonly log: Logger | undefined;
+    debug: boolean;
+    constructor(program: ts.Program, log?: Logger);
+    /**
+     * Analyze a source file to prepare for export processing.
+     */
+    analyze_source_file(source_file: ts.SourceFile): void;
+    /**
+     * Process a list of exported symbols and identify their kinds.
+     */
+    process_exports(source_file: ts.SourceFile, exports: Array<ts.Symbol>, declarations?: Array<ExportDeclaration>): Array<ExportDeclaration>;
+}
+//# sourceMappingURL=parse_exports_context.d.ts.map

package/dist/parse_exports_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_exports_context.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/parse_exports_context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAE1D;;GAEG;AACH,qBAAa,mBAAmB;;IAQ/B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,KAAK,UAAwC;gBAEjC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM;IAc7C;;OAEG;IACH,mBAAmB,CAAC,WAAW,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI;IAerD;;OAEG;IACH,eAAe,CACd,WAAW,EAAE,EAAE,CAAC,UAAU,EAC1B,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,EACzB,YAAY,GAAE,KAAK,CAAC,iBAAiB,CAAM,GACzC,KAAK,CAAC,iBAAiB,CAAC;CA+U3B"}

package/dist/parse_exports_context.js

@@ -0,0 +1,332 @@
+import ts from 'typescript';
+/**
+ * A class to track export context and determine export kinds.
+ */
+export class ParseExportsContext {
+    #checker;
+    // Map of source file paths to their symbols
+    #file_symbols = new Map();
+    // Cache for resolved symbols to avoid repeated resolution
+    #symbol_kind_cache = new Map();
+    log;
+    debug = process.env.DEBUG_EXPORTS === 'true';
+    constructor(program, log) {
+        this.log = log;
+        this.#checker = program.getTypeChecker();
+    }
+    /**
+     * Log a debug message if debug mode is enabled.
+     */
+    #log(...args) {
+        if (this.debug && this.log) {
+            this.log.info(...args);
+        }
+    }
+    /**
+     * Analyze a source file to prepare for export processing.
+     */
+    analyze_source_file(source_file) {
+        const file_path = source_file.fileName;
+        // Skip if we've already analyzed this file
+        if (this.#file_symbols.has(file_path)) {
+            return;
+        }
+        // Get the source file symbol and cache it
+        const symbol = this.#checker.getSymbolAtLocation(source_file);
+        if (symbol) {
+            this.#file_symbols.set(file_path, symbol);
+        }
+    }
+    /**
+     * Process a list of exported symbols and identify their kinds.
+     */
+    process_exports(source_file, exports, declarations = []) {
+        for (const export_symbol of exports) {
+            const name = export_symbol.name;
+            this.#log(`Determining kind for export: ${name}`);
+            const kind = this.#determine_export_kind(source_file, export_symbol);
+            declarations.push({
+                name,
+                kind,
+            });
+        }
+        return declarations;
+    }
+    /**
+     * Determine the kind of an export based on its symbol.
+     */
+    #determine_export_kind(source_file, symbol) {
+        // Check if this is a type-only export (no value export)
+        if (this.#is_type_only_export(source_file, symbol)) {
+            return 'type';
+        }
+        // Get the true symbol by resolving aliases
+        const resolved_symbol = this.#resolve_symbol(symbol);
+        // Check if we've already determined this symbol's kind
+        if (this.#symbol_kind_cache.has(resolved_symbol)) {
+            return this.#symbol_kind_cache.get(resolved_symbol);
+        }
+        // Determine the kind based on declaration and type information
+        const kind = this.#infer_declaration_kind(resolved_symbol);
+        // Cache the result for future lookups
+        this.#symbol_kind_cache.set(resolved_symbol, kind);
+        return kind;
+    }
+    /**
+     * Resolve a symbol through aliases to its original declaration.
+     */
+    #resolve_symbol(symbol) {
+        try {
+            if (symbol.flags & ts.SymbolFlags.Alias) {
+                return this.#checker.getAliasedSymbol(symbol);
+            }
+        }
+        catch {
+            // If resolution fails, return the original symbol
+        }
+        return symbol;
+    }
+    /**
+     * Infer the declaration kind from a symbol's declaration and type information.
+     */
+    #infer_declaration_kind(symbol) {
+        // Check symbol flags first for direct type matching
+        if (this.#is_class_symbol(symbol)) {
+            return 'class';
+        }
+        if (this.#is_function_symbol(symbol)) {
+            return 'function';
+        }
+        // If no direct match from flags, look at declarations
+        if (symbol.declarations && symbol.declarations.length > 0) {
+            const decl = symbol.declarations[0];
+            const kind_from_decl = this.#infer_kind_from_declaration(decl);
+            if (kind_from_decl) {
+                return kind_from_decl;
+            }
+        }
+        // Check for callable type as a fallback for functions
+        if (this.#is_callable(symbol)) {
+            return 'function';
+        }
+        // Default to variable if no other type can be determined
+        return 'variable';
+    }
+    /**
+     * Check if a symbol represents a callable type (function-like).
+     */
+    #is_callable(symbol) {
+        try {
+            // Try to get valid declaration node
+            const declaration = this.#get_valid_declaration(symbol);
+            if (!declaration) {
+                return false;
+            }
+            // Get the type at the declaration location
+            const type = this.#checker.getTypeOfSymbolAtLocation(symbol, declaration);
+            // Check if the type has call signatures (making it function-like)
+            return type.getCallSignatures().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get a valid declaration for a symbol, preferring valueDeclaration.
+     */
+    #get_valid_declaration(symbol) {
+        if (symbol.valueDeclaration) {
+            return symbol.valueDeclaration;
+        }
+        if (symbol.declarations && symbol.declarations.length > 0) {
+            return symbol.declarations[0];
+        }
+        return undefined;
+    }
+    /**
+     * Infer the declaration kind from a specific declaration node.
+     */
+    #infer_kind_from_declaration(decl) {
+        if (ts.isFunctionDeclaration(decl)) {
+            return 'function';
+        }
+        if (ts.isClassDeclaration(decl)) {
+            return 'class';
+        }
+        if (ts.isInterfaceDeclaration(decl) || ts.isTypeAliasDeclaration(decl)) {
+            return 'type';
+        }
+        if (ts.isVariableDeclaration(decl)) {
+            // Handle initializers for variable declarations
+            if (decl.initializer) {
+                if (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer)) {
+                    return 'function';
+                }
+                if (ts.isClassExpression(decl.initializer)) {
+                    return 'class';
+                }
+                // Handle identifiers pointing to other declarations
+                if (ts.isIdentifier(decl.initializer)) {
+                    try {
+                        const referred_symbol = this.#checker.getSymbolAtLocation(decl.initializer);
+                        if (referred_symbol) {
+                            // Avoid infinite recursion by not resolving symbols here
+                            if (this.#is_function_symbol(referred_symbol)) {
+                                return 'function';
+                            }
+                            if (this.#is_class_symbol(referred_symbol)) {
+                                return 'class';
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore failures to resolve identifiers
+                    }
+                }
+            }
+            // As a fallback, check if the variable's type is callable
+            try {
+                const symbol = this.#checker.getSymbolAtLocation(decl.name);
+                if (symbol && this.#is_callable(symbol)) {
+                    return 'function';
+                }
+            }
+            catch {
+                // Ignore errors in type checking
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a symbol is exported as a type-only export.
+     * A type-only export means it's ONLY exported as a type with no value export.
+     */
+    #is_type_only_export(source_file, symbol) {
+        // First, check if the symbol has an explicit type-only export
+        let has_type_only_export = false;
+        // Check if it has a corresponding value export
+        const has_value_export = this.#has_value_export(source_file, symbol);
+        // If it has both type and value exports (dual purpose), it's not type-only
+        if (has_value_export) {
+            return false;
+        }
+        // Check export declarations for explicit type-only exports
+        ts.forEachChild(source_file, (node) => {
+            if (ts.isExportDeclaration(node) &&
+                node.exportClause &&
+                ts.isNamedExports(node.exportClause)) {
+                // Check if it's a type-only export declaration (export type {...})
+                if (node.isTypeOnly) {
+                    for (const specifier of node.exportClause.elements) {
+                        if (specifier.name.text === symbol.name) {
+                            has_type_only_export = true;
+                        }
+                    }
+                }
+                else {
+                    // Check if it's a specific type export (export {type X})
+                    for (const specifier of node.exportClause.elements) {
+                        if (specifier.name.text === symbol.name && specifier.isTypeOnly) {
+                            has_type_only_export = true;
+                        }
+                    }
+                }
+            }
+        });
+        // If explicitly marked as a type-only export, use that
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (has_type_only_export) {
+            return true;
+        }
+        // If not explicitly marked as type-only, check if the symbol itself is a type
+        // AND there's no value export for it
+        const resolved_symbol = this.#resolve_symbol(symbol);
+        return this.#is_type_symbol(resolved_symbol) && !has_value_export;
+    }
+    /**
+     * Check if a symbol has a value export in the source file.
+     */
+    #has_value_export(source_file, symbol) {
+        let has_value_export = false;
+        // Check export declarations
+        ts.forEachChild(source_file, (node) => {
+            if (ts.isExportDeclaration(node) &&
+                node.exportClause &&
+                ts.isNamedExports(node.exportClause)) {
+                // Skip type-only exports
+                if (node.isTypeOnly)
+                    return;
+                // Check if it's a regular export (not type-only)
+                for (const specifier of node.exportClause.elements) {
+                    if (specifier.name.text === symbol.name && !specifier.isTypeOnly) {
+                        has_value_export = true;
+                    }
+                }
+            }
+            // Check for default export
+            else if (ts.isExportAssignment(node) && symbol.name === 'default') {
+                has_value_export = true;
+            }
+            // Check for direct exports (export const x = ...)
+            else if (this.#is_direct_export(node) && this.#get_export_name(node) === symbol.name) {
+                has_value_export = true;
+            }
+        });
+        return has_value_export;
+    }
+    /**
+     * Check if a node is a direct export (export const/function/class).
+     */
+    #is_direct_export(node) {
+        return ((ts.isVariableStatement(node) ||
+            ts.isFunctionDeclaration(node) ||
+            ts.isClassDeclaration(node)) &&
+            this.#has_export_modifier(node));
+    }
+    /**
+     * Get the export name from a direct export node.
+     */
+    #get_export_name(node) {
+        if (ts.isVariableStatement(node) && node.declarationList.declarations.length > 0) {
+            const decl = node.declarationList.declarations[0];
+            if (ts.isIdentifier(decl.name)) {
+                return decl.name.text;
+            }
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
+            return node.name.text;
+        }
+        else if (ts.isClassDeclaration(node) && node.name) {
+            return node.name.text;
+        }
+        return undefined;
+    }
+    /**
+     * Check if a node has an export modifier.
+     */
+    #has_export_modifier(node) {
+        return ((ts.canHaveModifiers(node) &&
+            ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) ||
+            false);
+    }
+    /**
+     * Check if a symbol is a function symbol.
+     */
+    #is_function_symbol(symbol) {
+        return !!(symbol.flags & ts.SymbolFlags.Function || symbol.flags & ts.SymbolFlags.Method);
+    }
+    /**
+     * Check if a symbol is a class symbol.
+     */
+    #is_class_symbol(symbol) {
+        return !!(symbol.flags & ts.SymbolFlags.Class);
+    }
+    /**
+     * Check if a symbol is a type-only symbol (interface, type alias, etc.).
+     */
+    #is_type_symbol(symbol) {
+        return !!(symbol.flags & ts.SymbolFlags.Interface ||
+            symbol.flags & ts.SymbolFlags.TypeAlias ||
+            symbol.flags & ts.SymbolFlags.TypeParameter);
+    }
+}

package/dist/parse_imports.d.ts

@@ -0,0 +1,5 @@
+import type { Flavored } from '@fuzdev/fuz_util/types.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+export type ImportSpecifier = Flavored<string, 'ImportSpecifier'>;
+export declare const parse_imports: (id: PathId, contents: string, ignore_types?: boolean) => Array<ImportSpecifier>;
+//# sourceMappingURL=parse_imports.d.ts.map

package/dist/parse_imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_imports.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/parse_imports.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAyBlE,eAAO,MAAM,aAAa,GACzB,IAAI,MAAM,EACV,UAAU,MAAM,EAChB,sBAAmB,KACjB,KAAK,CAAC,eAAe,CA+IvB,CAAC"}