@tlockney/cdp-kernel 0.4.0 → 0.6.0

package/dist/deno-types.js

@@ -0,0 +1,93 @@
+// Types for a Deno target's imports (#275). Deno resolves npm:, jsr:, URLs
+// and its project's import map itself and keeps what it fetched in its own
+// cache, so the language service asks it where a specifier went:
+// `deno info --json` over a one-line module importing it. npm packages map
+// to their directory in Deno's npm cache; remote modules (jsr:, https:)
+// are stored under hashed names without an extension, so the language
+// service sees each under a virtual path built from its URL, which keeps
+// relative imports between them working.
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function runDeno(deno) {
+    return (args) => {
+        const result = spawnSync(deno, args, { encoding: "utf8", timeout: 30_000, maxBuffer: 64 * 1024 * 1024 });
+        return { status: result.status, stdout: result.stdout ?? "" };
+    };
+}
+export class DenoResolver {
+    #run;
+    #config;
+    /** Where remote modules appear to the language service. */
+    root;
+    #lookups = new Map();
+    /** Virtual path -> the cached file holding that URL's module. */
+    #remote = new Map();
+    constructor({ deno = "deno", config = null, root }, run = runDeno(deno)) {
+        this.#run = run;
+        this.#config = config;
+        this.root = root;
+    }
+    /** The virtual path for a remote module's URL, e.g. <root>/https/jsr.io/@std/path/1.1.6/mod.ts. */
+    pathFor(url) {
+        const m = /^(https?):\/\/(.+)$/.exec(url);
+        return m ? join(this.root, m[1], m[2]) : null;
+    }
+    /** The cached file behind a virtual path, if a lookup has found it. */
+    localFile(path) {
+        return this.#remote.get(path);
+    }
+    /** Where `specifier` resolves for Deno, from what's already in its cache. */
+    lookup(specifier) {
+        if (this.#lookups.has(specifier))
+            return this.#lookups.get(specifier) ?? null;
+        const resolution = this.#lookup(specifier);
+        this.#lookups.set(specifier, resolution);
+        return resolution;
+    }
+    #lookup(specifier) {
+        const dir = mkdtempSync(join(tmpdir(), "cdpk-deno-info-"));
+        try {
+            const entry = join(dir, "entry.ts");
+            writeFileSync(entry, `import ${JSON.stringify(specifier)};\n`);
+            const flags = this.#config === null ? ["--node-modules-dir=none"] : ["--config", this.#config];
+            const result = this.#run(["info", "--json", "--no-lock", ...flags, entry]);
+            if (result.status !== 0)
+                return null;
+            return this.#read(JSON.parse(result.stdout));
+        }
+        catch {
+            return null;
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    #read(info) {
+        for (const mod of info.modules) {
+            const path = mod.local === undefined ? null : this.pathFor(mod.specifier);
+            if (path !== null && mod.local !== undefined)
+                this.#remote.set(path, mod.local);
+        }
+        const root = info.modules.find((m) => m.specifier === info.roots[0]);
+        const dep = root?.dependencies?.[0];
+        let target = dep?.code?.specifier ?? dep?.specifier;
+        if (target === undefined)
+            return null;
+        for (let i = 0; i < 10 && info.redirects[target] !== undefined; i++)
+            target = info.redirects[target];
+        const npm = /^npm:\/?((?:@[^/]+\/)?[^/@]+@[^/]+)(\/.*)?$/.exec(target);
+        if (npm) {
+            const dir = info.npmPackages[npm[1]]?.localPath;
+            return dir === undefined ? null : { kind: "npm", dir, subpath: npm[2] ?? "" };
+        }
+        const path = this.pathFor(target);
+        return path !== null && this.#remote.has(path) ? { kind: "remote", path } : null;
+    }
+}
+/** `deno types`: declarations for the Deno namespace and its web globals. */
+export function denoTypes(run = runDeno("deno")) {
+    const result = run(["types"]);
+    return result.status === 0 ? result.stdout : null;
+}

package/dist/globals.d.ts

@@ -2,9 +2,9 @@
  * Ambient types for notebook cells run by cdp-kernel: the `jupyter` display
  * namespace and the stdin-backed `prompt`/`confirm`.
  *
- * Load it once per project, for example
- * `/// <reference types="@tlockney/cdp-kernel/globals" />` (npm) or
- * `import type {} from "jsr:@tlockney/cdp-kernel/globals";` (Deno).
+ * Load it once per project, for example with
+ * `/// <reference types="@tlockney/cdp-kernel/globals" />`. It ships in the
+ * npm package only: Deno notebooks use `Deno.jupyter`, which Deno types.
  *
  * A custom display is a class with a `[jupyter.$display]()` method returning
  * a media bundle. At runtime that key is `Symbol.for("Jupyter.display")`, but

package/dist/globals.js

@@ -2,9 +2,9 @@
  * Ambient types for notebook cells run by cdp-kernel: the `jupyter` display
  * namespace and the stdin-backed `prompt`/`confirm`.
  *
- * Load it once per project, for example
- * `/// <reference types="@tlockney/cdp-kernel/globals" />` (npm) or
- * `import type {} from "jsr:@tlockney/cdp-kernel/globals";` (Deno).
+ * Load it once per project, for example with
+ * `/// <reference types="@tlockney/cdp-kernel/globals" />`. It ships in the
+ * npm package only: Deno notebooks use `Deno.jupyter`, which Deno types.
  *
  * A custom display is a class with a `[jupyter.$display]()` method returning
  * a media bundle. At runtime that key is `Symbol.for("Jupyter.display")`, but

package/dist/kernel.d.ts

@@ -1,4 +1,5 @@
 import { type RuntimeName } from "./target.ts";
+import { type TypeStripper, type TypeStripperName } from "./transform.ts";
 export interface ConnectionInfo {
     ip: string;
     key: string;
@@ -14,8 +15,13 @@ export declare function parseConnectionInfo(json: string): ConnectionInfo;
 export declare class Kernel {
     #private;
     constructor(conn: ConnectionInfo, runtime: RuntimeName, options?: {
-        denoCompat?: boolean; /** Defaults to the process cwd, which Jupyter sets. */
+        denoCompat?: boolean;
+        /** Defaults to the process cwd, which Jupyter sets. */
         notebookDir?: string;
+        /** What strips cells' types; esbuild by default (#238). */
+        typeStrip?: TypeStripperName | TypeStripper;
+        /** Typed completion from TypeScript's language service; on by default (#273). */
+        languageService?: boolean;
     });
     run(): Promise<void>;
 }