@ryanatkn/gro 0.156.0 → 0.157.1

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 Parse_Exports_Context {
+    #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.map

@@ -1 +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,yBAAyB,CAAC;AAGtD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAIvC,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAyBpE,eAAO,MAAM,aAAa,GACzB,IAAI,OAAO,EACX,UAAU,MAAM,EAChB,sBAAmB,KACjB,KAAK,CAAC,gBAAgB,CA+IxB,CAAC"}
+{"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,yBAAyB,CAAC;AAGtD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAGvC,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAyBpE,eAAO,MAAM,aAAa,GACzB,IAAI,OAAO,EACX,UAAU,MAAM,EAChB,sBAAmB,KACjB,KAAK,CAAC,gBAAgB,CA+IxB,CAAC"}

package/dist/parse_imports.js

@@ -1,7 +1,6 @@
 import { parseSync } from 'oxc-parser';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
-import { SVELTE_MATCHER } from "./svelte_helpers.js";
-import { JS_MATCHER, TS_MATCHER, SVELTE_SCRIPT_MATCHER } from "./constants.js";
+import { JS_MATCHER, TS_MATCHER, SVELTE_MATCHER, SVELTE_SCRIPT_MATCHER } from "./constants.js";
 // TODO this is probably way more complicated that it should be, maybe report the issues upstream unless I made a mistake here
 /**
  * Extracts the string value from a module request, handling different quote styles.

package/dist/paths.d.ts

@@ -1,13 +1,19 @@
 import type { Path_Id } from './path.ts';
 export declare const LIB_DIRNAME: string;
 export declare const LIB_PATH: string;
+/** @trailing_slash */
 export declare const LIB_DIR: string;
 export declare const ROUTES_DIRNAME: string;
 export interface Paths {
+    /** @trailing_slash */
     root: string;
+    /** @trailing_slash */
     source: string;
+    /** @trailing_slash */
     lib: string;
+    /** @trailing_slash */
     build: string;
+    /** @trailing_slash */
     build_dev: string;
     config: string;
 }
@@ -23,11 +29,13 @@ export declare const replace_extension: (path: string, new_extension: string) =>
  * Paths for the user repo.
  */
 export declare const paths: Paths;
+/** @trailing_slash */
 export declare const GRO_PACKAGE_DIR = "gro/";
 export declare const IS_THIS_GRO: boolean;
 /**
  * Paths for the Gro package being used by the user repo.
  */
 export declare const gro_paths: Paths;
+/** @trailing_slash */
 export declare const GRO_DIST_DIR: string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/paths.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AASvC,eAAO,MAAM,WAAW,QAA2C,CAAC;AACpE,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,OAAO,QAAiB,CAAC;AACtC,eAAO,MAAM,cAAc,QAA8C,CAAC;AAE1E,MAAM,WAAW,KAAK;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,KAAG,KAW/C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,IAAI,OAAO,KAAG,KAA4C,CAAC;AACvF,eAAO,MAAM,SAAS,GAAI,IAAI,OAAO,KAAG,OAAwD,CAAC;AAGjG,eAAO,MAAM,YAAY,GAAI,IAAI,OAAO,EAAE,SAAmB,KAAG,MACnC,CAAC;AAG9B,eAAO,MAAM,oBAAoB,GAAI,SAAS,OAAO,EAAE,SAAwB,KAAG,MACtD,CAAC;AAI7B,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,EAAE,SAA0B,KAAG,OAC3D,CAAC;AAE3B,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,SAAqB,KAAG,MAMhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,EAAE,eAAe,MAAM,KAAG,MAGvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,OAA8B,CAAC;AAEjD,eAAO,MAAM,eAAe,SAAS,CAAC;AAYtC,eAAO,MAAM,WAAW,SAAsC,CAAC;AAC/D;;GAEG;AACH,eAAO,MAAM,SAAS,OAA2D,CAAC;AAClF,eAAO,MAAM,YAAY,QAAgD,CAAC"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/paths.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AASvC,eAAO,MAAM,WAAW,QAA2C,CAAC;AACpE,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,sBAAsB;AACtB,eAAO,MAAM,OAAO,QAAiB,CAAC;AACtC,eAAO,MAAM,cAAc,QAA8C,CAAC;AAE1E,MAAM,WAAW,KAAK;IACrB,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,KAAG,KAW/C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,IAAI,OAAO,KAAG,KAA4C,CAAC;AAEvF,eAAO,MAAM,SAAS,GAAI,IAAI,OAAO,KAAG,OACgC,CAAC;AAGzE,eAAO,MAAM,YAAY,GAAI,IAAI,OAAO,EAAE,SAAmB,KAAG,MACnC,CAAC;AAG9B,eAAO,MAAM,oBAAoB,GAAI,SAAS,OAAO,EAAE,SAAwB,KAAG,MACtD,CAAC;AAI7B,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,EAAE,SAA0B,KAAG,OAC3D,CAAC;AAE3B,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,SAAqB,KAAG,MAMhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,EAAE,eAAe,MAAM,KAAG,MAGvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,OAA8B,CAAC;AAEjD,sBAAsB;AACtB,eAAO,MAAM,eAAe,SAAS,CAAC;AAYtC,eAAO,MAAM,WAAW,SAAsC,CAAC;AAC/D;;GAEG;AACH,eAAO,MAAM,SAAS,OAA2D,CAAC;AAClF,sBAAsB;AACtB,eAAO,MAAM,YAAY,QAAgD,CAAC"}

package/dist/paths.js

@@ -1,6 +1,6 @@
 import { join, extname, relative, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { strip_end } from '@ryanatkn/belt/string.js';
+import { ensure_end, strip_end } from '@ryanatkn/belt/string.js';
 import { styleText as st } from 'node:util';
 import { GRO_CONFIG_PATH, GRO_DEV_DIR, GRO_DIR, SOURCE_DIR, SVELTEKIT_DIST_DIRNAME, } from "./constants.js";
 import { default_svelte_config } from "./svelte_config.js";
@@ -12,11 +12,12 @@ It's the same name that Rollup uses.
 */
 export const LIB_DIRNAME = basename(default_svelte_config.lib_path);
 export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
+/** @trailing_slash */
 export const LIB_DIR = LIB_PATH + '/';
 export const ROUTES_DIRNAME = basename(default_svelte_config.routes_path);
 export const create_paths = (root_dir) => {
     // TODO remove reliance on trailing slash towards windows support
-    const root = strip_end(root_dir, '/') + '/';
+    const root = ensure_end(root_dir, '/');
     return {
         root,
         source: root + SOURCE_DIR,
@@ -27,7 +28,7 @@ export const create_paths = (root_dir) => {
     };
 };
 export const infer_paths = (id) => (is_gro_id(id) ? gro_paths : paths);
-export const is_gro_id = (id) => id.startsWith(strip_end(gro_paths.root, '/')); // strip `/` in case we're looking at the Gro root without a trailing slash
+export const is_gro_id = (id) => id.startsWith(gro_paths.root) || gro_paths.root === ensure_end(id, '/');
 // '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
 export const to_root_path = (id, p = infer_paths(id)) => relative(p.root, id) || './';
 // '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
@@ -49,6 +50,7 @@ export const replace_extension = (path, new_extension) => {
  * Paths for the user repo.
  */
 export const paths = create_paths(process.cwd());
+/** @trailing_slash */
 export const GRO_PACKAGE_DIR = 'gro/';
 // TODO document these conditions with comments
 // TODO there's probably a more robust way to do this
@@ -63,4 +65,5 @@ export const IS_THIS_GRO = gro_package_dir_path === paths.root;
  * Paths for the Gro package being used by the user repo.
  */
 export const gro_paths = IS_THIS_GRO ? paths : create_paths(gro_package_dir_path);
+/** @trailing_slash */
 export const GRO_DIST_DIR = gro_paths.root + SVELTEKIT_DIST_DIRNAME + '/';