sliftutils 1.7.6 → 1.7.8

package/bundler/bundleEntry.ts

@@ -12,10 +12,22 @@ async function main() {
     if (!outputFolder) {
         throw new Error("No output folder provided. Please use the --outputFolder option.");
     }
-    // We prefer production, as this is what the bundler uses internally. This ensures that in the build and when run, we will have the same environment, which will result in the same requires being called. 
+    // We prefer production, as this is what the bundler uses internally. This ensures that in the build and when run, we will have the same environment, which will result in the same requires being called.
     process.env.NODE_ENV = process.env.NODE_ENV || "production";
     require(entryPoint);
 
+    // Warm pass: this process only exists to compile the entry's whole graph
+    // (and this bundler's own modules, compiled at our startup) into typenode's
+    // on-disk cache, then exit. The caller runs a SECOND, fresh process for the
+    // real bundle — that process reads everything from the warm cache and so
+    // never has typenode lazy-load the TypeScript compiler. Without this, a
+    // cold-cache build (e.g. a fresh CI/server checkout, or an entry whose files
+    // no other entry imports) leaves `typescript` in require.cache and the
+    // bundler serializes the entire 9 MB+ compiler into the output bundle.
+    if (process.argv[4] === "--warm") {
+        return;
+    }
+
     let name = path.basename(entryPoint);
     if (name.endsWith(".ts") || name.endsWith(".tsx")) {
         name = name.split(".").slice(0, -1).join(".");

package/bundler/bundleEntryCaller.ts

@@ -10,5 +10,13 @@ export async function bundleEntryCaller(config: {
     entryPoint = path.resolve(entryPoint).replace(/\\/g, "/");
     outputFolder = path.resolve(outputFolder).replace(/\\/g, "/");
     let bundleEntryPath = path.resolve(__dirname, "bundleEntry.ts").replace(/\\/g, "/");
-    await runPromise(`node -r ./node_modules/typenode/index.js ${JSON.stringify(bundleEntryPath)} ${JSON.stringify(entryPoint)} ${JSON.stringify(outputFolder)}`);
+    let base = `node -r ./node_modules/typenode/index.js ${JSON.stringify(bundleEntryPath)} ${JSON.stringify(entryPoint)} ${JSON.stringify(outputFolder)}`;
+    // Run twice in SEPARATE processes. The first ("--warm") only imports the
+    // entry, which compiles its whole graph into typenode's on-disk cache. The
+    // second is a fresh process that imports from that warm cache — so typenode
+    // never has to compile anything and never lazy-loads the TypeScript compiler,
+    // which would otherwise be captured in require.cache and serialized (9 MB+)
+    // into the output bundle. See bundleEntry.ts.
+    await runPromise(`${base} --warm`);
+    await runPromise(base);
 }

package/index.d.ts

@@ -2423,6 +2423,7 @@ declare module "sliftutils/storage/fileSystemPointer" {
         handle: FileSystemFileHandle | FileSystemDirectoryHandle;
     }): Promise<FileSystemPointer>;
     export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+    export declare function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined>;
     export declare function getFileSystemPointer(config: {
         pointer: FileSystemPointer;
     }): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.6",
+    "version": "1.7.8",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/FileFolderAPI.tsx

@@ -1,5 +1,5 @@
 import preact from "preact";
-import { getFileSystemPointer, storeFileSystemPointer } from "./fileSystemPointer";
+import { findGrantedPointerHandle, getFileSystemPointer, storeFileSystemPointer } from "./fileSystemPointer";
 import { observable } from "mobx";
 import { observer } from "../render-utils/observer";
 import { cache, lazy } from "socket-function/src/caching";
@@ -36,6 +36,9 @@ declare global {
 // DO NOT enable this is isNode
 const USE_INDEXED_DB = false;
 
+// How often a worker rechecks the pointer IndexedDB for a granted handle when none is available yet.
+const WORKER_POLL_INTERVAL_MS = 60 * 1000;
+
 // These mirror the subset of the native FileSystemFileHandle / FileSystemDirectoryHandle API we use, so
 // the native browser handles, the Node handles, and the remote handles are all interchangeable — and
 // code written against the native handle (e.g. a recursive walk over `handle.entries()`) works on any of
@@ -460,6 +463,20 @@ export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Prom
     if (storageRootOverride) {
         return storageRootOverride as unknown as DirectoryWrapper;
     }
+    // A worker can't show the picker (no DOM / no user activation) and can't read localStorage, but
+    // it CAN open the pointer IndexedDB the main-thread picker persists to. Poll it for a handle
+    // whose permission is already granted; the owning window may also postMessage a handle in
+    // mid-poll (checked each iteration). This has to come before the isNode branch: typesafecss's
+    // isNode() returns true in workers (window is undefined), so a worker would otherwise fall into
+    // the Node branch and try to use fs/path.
+    if ("WorkerGlobalScope" in globalThis) {
+        while (true) {
+            if (storageRootOverride) return storageRootOverride as unknown as DirectoryWrapper;
+            let handle = await findGrantedPointerHandle("readwrite");
+            if (handle) return handle as unknown as DirectoryWrapper;
+            await new Promise(resolve => setTimeout(resolve, WORKER_POLL_INTERVAL_MS));
+        }
+    }
     if (isNode()) {
         return new NodeJSDirectoryHandleWrapper(path.resolve("./data/"));
     }

package/storage/fileSystemPointer.d.ts

@@ -4,6 +4,7 @@ export declare function storeFileSystemPointer(config: {
     handle: FileSystemFileHandle | FileSystemDirectoryHandle;
 }): Promise<FileSystemPointer>;
 export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+export declare function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined>;
 export declare function getFileSystemPointer(config: {
     pointer: FileSystemPointer;
 }): Promise<{

package/storage/fileSystemPointer.ts

@@ -55,6 +55,36 @@ export async function deleteFileSystemPointer(pointer: FileSystemPointer) {
     });
 }
 
+// Enumerates every stored pointer handle whose permission is already granted for `mode`, newest first
+// (pointer keys start with Date.now(), which sorts lexicographically). Callable from a Web Worker —
+// unlike getFileSystemPointer's onUserActivation flow, this only uses queryPermission, which does
+// NOT require user activation.
+export async function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined> {
+    let database = await db();
+    if (!database) return undefined;
+    let store = database.transaction(objectStoreName, "readonly").objectStore(objectStoreName);
+    let keysReq = store.getAllKeys();
+    let valuesReq = store.getAll();
+    await new Promise((resolve, reject) => {
+        keysReq.addEventListener("success", resolve);
+        keysReq.addEventListener("error", reject);
+    });
+    await new Promise((resolve, reject) => {
+        valuesReq.addEventListener("success", resolve);
+        valuesReq.addEventListener("error", reject);
+    });
+    let keys = keysReq.result as string[];
+    let values = valuesReq.result as (FileSystemFileHandle | FileSystemDirectoryHandle)[];
+    let entries = keys.map((key, i) => ({ key, value: values[i], time: +key.split("_")[0] || 0 }))
+        .sort((a, b) => b.time - a.time);
+    for (let entry of entries) {
+        if (entry.value.kind !== "directory") continue;
+        let state = await (entry.value as any).queryPermission({ mode });
+        if (state === "granted") return entry.value;
+    }
+    return undefined;
+}
+
 export async function getFileSystemPointer(config: {
     pointer: FileSystemPointer;
 }): Promise<{