@ryanatkn/gro 0.190.1 → 0.192.0

package/dist/parse_exports_context.js

@@ -1,332 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/parse_imports.js

@@ -1,140 +0,0 @@
-import { parseSync } from 'oxc-parser';
-import { UnreachableError } from '@fuzdev/fuz_util/error.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.
- * Returns null if the value is not a valid string literal.
- */
-const extract_string_literal = (content, start, end) => {
-    const value = content.substring(start, end);
-    // Check if it's a string literal (starts and ends with quotes)
-    if ((value.startsWith("'") && value.endsWith("'")) ||
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith('`') && value.endsWith('`'))) {
-        // Remove the quotes
-        return value.slice(1, -1);
-    }
-    // Not a valid string literal
-    return null;
-};
-export const parse_imports = (id, contents, ignore_types = true) => {
-    const specifiers = [];
-    const is_svelte = SVELTE_MATCHER.test(id);
-    const parse_from = (s) => {
-        const parsed = parseSync(is_svelte ? id + '.ts' : id, s, {});
-        // Process static imports
-        for (const static_import of parsed.module.staticImports) {
-            // Get the module source node
-            const import_decl = parsed.program.body.find((node) => node.type === 'ImportDeclaration' && node.start === static_import.start);
-            if (!import_decl?.source)
-                continue;
-            // Extract the module request string value
-            const value = extract_string_literal(s, import_decl.source.start, import_decl.source.end);
-            if (!value)
-                continue;
-            // Skip type-only imports if ignore_types is true
-            if (ignore_types) {
-                // Handle import type {...} (type-only imports)
-                if (import_decl.importKind === 'type') {
-                    continue;
-                }
-                // Handle inline type imports ({type foo})
-                if (static_import.entries.length > 0) {
-                    // If all imports are type imports, skip this import
-                    const has_non_type_specifier = static_import.entries.some((entry) => !entry.isType);
-                    if (!has_non_type_specifier) {
-                        continue;
-                    }
-                }
-            }
-            specifiers.push(value);
-        }
-        // Process dynamic imports
-        for (const dynamic_import of parsed.module.dynamicImports) {
-            // Find the corresponding AST node
-            let found = false;
-            for (const node of parsed.program.body) {
-                if (node.type === 'ExpressionStatement' &&
-                    node.expression.type === 'AwaitExpression' &&
-                    node.expression.argument.type === 'ImportExpression') {
-                    const import_expr = node.expression.argument;
-                    if (import_expr.start === dynamic_import.start) {
-                        // Only process string literals (not expressions or variables)
-                        if (import_expr.source.type === 'Literal') {
-                            const value = String(import_expr.source.value);
-                            if (value) {
-                                specifiers.push(value);
-                            }
-                        }
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            // If we didn't find a match through AST, fall back to the original approach
-            // but only for simple string literals
-            if (!found) {
-                const value = extract_string_literal(s, dynamic_import.moduleRequest.start, dynamic_import.moduleRequest.end);
-                if (value) {
-                    specifiers.push(value);
-                }
-            }
-        }
-        // Process re-exports
-        for (const node of parsed.program.body) {
-            if (node.type === 'ExportNamedDeclaration' && node.source) {
-                // Skip type-only exports if ignore_types is true
-                if (ignore_types && node.exportKind === 'type') {
-                    continue;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (node.source.type === 'Literal') {
-                    const value = node.source.value;
-                    if (value) {
-                        specifiers.push(value);
-                    }
-                }
-                else {
-                    throw new UnreachableError(node.source.type);
-                }
-            }
-        }
-    };
-    if (is_svelte) {
-        // Reset the regexp state between calls
-        SVELTE_SCRIPT_MATCHER.lastIndex = 0;
-        // Capture script tags at the top level (not nested in HTML)
-        let last_index = 0;
-        const script_blocks = [];
-        // First collect all script blocks
-        let match;
-        while ((match = SVELTE_SCRIPT_MATCHER.exec(contents)) !== null) {
-            // Save position of the script tag
-            const start = match.index;
-            const end = SVELTE_SCRIPT_MATCHER.lastIndex;
-            // Only process top-level script tags (skip nested ones)
-            // A nested script would be inside another HTML tag between lastIndex and start
-            const text_between = contents.substring(last_index, start);
-            const contains_opening_tag = /<[a-z][^>]*>/i.test(text_between);
-            const contains_closing_tag = /<\/[a-z][^>]*>/i.test(text_between);
-            // If we're not nested (no HTML tag nesting), process this script
-            if (!(contains_opening_tag && !contains_closing_tag)) {
-                script_blocks.push({
-                    content: match[1],
-                    start,
-                    end,
-                });
-            }
-            last_index = end;
-        }
-        // Process all the collected script blocks
-        for (const script_block of script_blocks) {
-            parse_from(script_block.content);
-        }
-    }
-    else if (TS_MATCHER.test(id) || JS_MATCHER.test(id)) {
-        parse_from(contents);
-    }
-    return specifiers;
-};

package/dist/paths.d.ts

@@ -1,41 +0,0 @@
-import type { PathId } from '@fuzdev/fuz_util/path.js';
-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;
-}
-export declare const create_paths: (root_dir: string) => Paths;
-export declare const infer_paths: (id: PathId) => Paths;
-export declare const is_gro_id: (id: PathId) => boolean;
-export declare const to_root_path: (id: PathId, p?: Paths) => string;
-export declare const path_id_to_base_path: (path_id: PathId, p?: Paths) => string;
-export declare const base_path_to_path_id: (base_path: string, p?: Paths) => PathId;
-export declare const print_path: (path: string, p?: Paths) => string;
-export declare const replace_extension: (path: string, new_extension: string) => 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 +0,0 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/paths.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAkBrD,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,MAAM,KAAG,KAA4C,CAAC;AAEtF,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,KAAG,OACiC,CAAC;AAGzE,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,EAAE,SAAmB,KAAG,MAClC,CAAC;AAG9B,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,EAAE,SAAwB,KAAG,MACrD,CAAC;AAI7B,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,EAAE,SAA0B,KAAG,MAC3D,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,69 +0,0 @@
-import { join, extname, relative, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensure_end, strip_end } from '@fuzdev/fuz_util/string.js';
-import { styleText as st } from 'node:util';
-import { GRO_CONFIG_FILENAME, GRO_DEV_DIR, GRO_DIR, SOURCE_DIR, SVELTEKIT_DIST_DIRNAME, } from "./constants.js";
-import { default_svelte_config } from "./svelte_config.js";
-/*
-
-A path `id` is an absolute path to the source/.gro/dist directory.
-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 = ensure_end(root_dir, '/');
-    return {
-        root,
-        source: root + SOURCE_DIR,
-        lib: root + LIB_DIR,
-        build: root + GRO_DIR,
-        build_dev: root + GRO_DEV_DIR,
-        config: root + GRO_CONFIG_FILENAME,
-    };
-};
-export const infer_paths = (id) => (is_gro_id(id) ? gro_paths : paths);
-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'
-export const path_id_to_base_path = (path_id, p = infer_paths(path_id)) => relative(p.source, path_id);
-// TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
-// 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
-export const base_path_to_path_id = (base_path, p = infer_paths(base_path)) => join(p.source, base_path);
-export const print_path = (path, p = infer_paths(path)) => {
-    let final_path = strip_end(path, '/') === strip_end(GRO_DIST_DIR, '/') ? 'gro' : to_root_path(path, p);
-    final_path =
-        final_path === 'gro' ? final_path : final_path[0] === '.' ? final_path : './' + final_path;
-    return st('gray', final_path);
-};
-export const replace_extension = (path, new_extension) => {
-    const { length } = extname(path);
-    return (length === 0 ? path : path.substring(0, path.length - length)) + 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
-const filename = fileURLToPath(import.meta.url);
-const gro_package_dir_path = join(filename, filename.includes('/gro/src/lib/')
-    ? '../../../'
-    : filename.includes('/gro/dist/')
-        ? '../../'
-        : '../');
-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 + '/';

package/dist/plugin.d.ts

@@ -1,36 +0,0 @@
-import type { TaskContext } from './task.ts';
-/**
- * Gro `Plugin`s enable custom behavior during `gro dev` and `gro build`.
- * In contrast, `Adapter`s use the results of `gro build` to produce final artifacts.
- */
-export interface Plugin<TPluginContext extends PluginContext = PluginContext> {
-    name: string;
-    setup?: (ctx: TPluginContext) => void | Promise<void>;
-    adapt?: (ctx: TPluginContext) => void | Promise<void>;
-    teardown?: (ctx: TPluginContext) => void | Promise<void>;
-}
-export type PluginsCreateConfig<TPluginContext extends PluginContext = PluginContext> = (ctx: TPluginContext) => Array<Plugin<TPluginContext>> | Promise<Array<Plugin<TPluginContext>>>;
-export interface PluginContext<TArgs = object> extends TaskContext<TArgs> {
-    dev: boolean;
-    watch: boolean;
-}
-/** See `Plugins.create` for a usage example. */
-export declare class Plugins<TPluginContext extends PluginContext> {
-    readonly ctx: TPluginContext;
-    readonly instances: Array<Plugin<TPluginContext>>;
-    constructor(ctx: TPluginContext, instances: Array<Plugin>);
-    static create<TPluginContext extends PluginContext>(ctx: TPluginContext): Promise<Plugins<TPluginContext>>;
-    setup(): Promise<void>;
-    adapt(): Promise<void>;
-    teardown(): Promise<void>;
-}
-/**
- * Replaces a plugin by name in `plugins` without mutating the param.
- * Throws if the plugin name cannot be found.
- * @param plugins - accepts the same types as the return value of `PluginsCreateConfig`
- * @param new_plugin
- * @param name - @default new_plugin.name
- * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
- */
-export declare const plugin_replace: (plugins: Array<Plugin>, new_plugin: Plugin, name?: string) => Array<Plugin>;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAE3C;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,cAAc,SAAS,aAAa,GAAG,aAAa;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD;AAED,MAAM,MAAM,mBAAmB,CAAC,cAAc,SAAS,aAAa,GAAG,aAAa,IAAI,CACvF,GAAG,EAAE,cAAc,KACf,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;AAE5E,MAAM,WAAW,aAAa,CAAC,KAAK,GAAG,MAAM,CAAE,SAAQ,WAAW,CAAC,KAAK,CAAC;IACxE,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CACf;AAED,gDAAgD;AAChD,qBAAa,OAAO,CAAC,cAAc,SAAS,aAAa;IACxD,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;gBAEtC,GAAG,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC;WAK5C,MAAM,CAAC,cAAc,SAAS,aAAa,EACvD,GAAG,EAAE,cAAc,GACjB,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAS7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAc/B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,MAAM,CAAC,EACtB,YAAY,MAAM,EAClB,aAAsB,KACpB,KAAK,CAAC,MAAM,CAMd,CAAC"}