@loopdive/js2 0.57.0

package/dist/resolve.d.ts

@@ -0,0 +1,82 @@
+import { CompileOptions } from './index.js';
+/**
+ * Module resolver that uses TypeScript's built-in `ts.resolveModuleName()`
+ * to resolve bare specifiers (e.g., "lodash") and relative specifiers
+ * (e.g., "./utils") to actual file paths on disk.
+ */
+export declare class ModuleResolver {
+    private rootDir;
+    private compilerOptions;
+    private host;
+    private externals;
+    private extensions;
+    private resolveCache;
+    constructor(rootDir: string, options?: CompileOptions);
+    /**
+     * Try to load tsconfig.json paths configuration from the root directory.
+     */
+    private loadTsconfigPaths;
+    /**
+     * Resolve a module specifier to a file path.
+     *
+     * @param specifier - The import specifier (e.g., "lodash", "./utils")
+     * @param containingFile - The file that contains the import statement
+     * @returns The resolved file path, or null if the module is external or not found
+     */
+    resolve(specifier: string, containingFile: string): string | null;
+    /**
+     * When `ts.resolveModuleName` returned a file under `@types/<pkg>/`,
+     * attempt to find the matching real implementation body in a sibling
+     * `node_modules/<pkg>/` directory and return its absolute path, or null
+     * if no implementation file can be located.
+     *
+     * Handles both standard npm layouts (`node_modules/<pkg>/...`) and pnpm
+     * layouts (where `@types/<pkg>` lives under `.pnpm/` but the real package
+     * is still hoisted to the top-level `node_modules/<pkg>`). The search
+     * walks up from `containingFile` through parent directories looking for
+     * each candidate — this matches Node's own module resolution walk.
+     */
+    private findImplementationBody;
+    private tryStatDir;
+    private tryStatFile;
+    /**
+     * Given a package root (e.g. `.../node_modules/lodash-es`) and a subpath
+     * from a specifier (e.g. `identity.js` or `identity` or ``), attempt to
+     * locate the implementation file on disk using the probe extensions.
+     */
+    private probeImplementationPath;
+    /**
+     * Check if a specifier refers to an external package.
+     */
+    isExternal(specifier: string): boolean;
+}
+/**
+ * Extract the bare package name from a specifier.
+ * Returns null for relative/absolute paths.
+ *
+ * Examples:
+ * - "lodash" → "lodash"
+ * - "lodash/fp" → "lodash"
+ * - "@scope/pkg" → "@scope/pkg"
+ * - "@scope/pkg/sub" → "@scope/pkg"
+ * - "./utils" → null
+ * - "/absolute/path" → null
+ */
+export declare function getBarePackageName(specifier: string): string | null;
+/**
+ * Recursively resolve all imports starting from an entry file,
+ * building a complete dependency graph.
+ *
+ * Files are returned in topological order (deps first, importers last,
+ * entry last). This is essential for module-init code generation:
+ * top-level statements that depend on imported variables must run
+ * after their dependencies' top-level statements (#1109).
+ *
+ * Cycles are tolerated — when re-entering a node we drop the back-edge
+ * and continue the post-order walk. The result mirrors ES module
+ * evaluation order: each module's body runs after its imports' bodies,
+ * with cycles broken by the first-seen position.
+ *
+ * @returns A map of file paths to source contents (including the entry file)
+ */
+export declare function resolveAllImports(entryFile: string, resolver: ModuleResolver): Map<string, string>;

package/dist/runtime/builtins.d.ts

@@ -0,0 +1 @@
+export {};