@inkandswitch/patchwork-bootloader 0.4.3 → 0.5.0

package/dist/vite/importmap-plugin.js

@@ -1,105 +0,0 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-const require = createRequire(import.meta.url);
-/**
- * these dependencies will be built into the outdir,
- * and injected into the importmap
- */
-import externals from "../externals.js";
-export const builtins = externals.reduce((builtins, name) => ((builtins[name] = `/packages/${name}.js`), builtins), {});
-/**
- * pretend the import came from inside this package, so node_modules resolution
- * walks up from *our* directory and finds our copy of each external. that's why
- * a consuming site never has to install them or agree with us about versions.
- */
-const self = fileURLToPath(import.meta.url);
-/**
- * resolve an external from our node_modules rather than the site's.
- *
- * this goes through rollup's resolver rather than import.meta.resolve or
- * require.resolve because those apply node's conditions: subduction (and
- * others) would hand us `dist/esm/node.js`, which imports node:path and blows
- * up at bundle time. rollup applies the browser conditions vite configured.
- */
-async function resolveExternal(name) {
-    const resolved = await this.resolve(name, self, { skipSelf: true });
-    if (!resolved) {
-        throw new Error(`@patchwork/vite: couldn't resolve the external "${name}" from ` +
-            `@inkandswitch/patchwork-bootloader. it should be one of the ` +
-            `bootloader's own dependencies.`);
-    }
-    return resolved.id;
-}
-/**
- * merge the importmap option with our builtins
- */
-function createImportMap(options) {
-    const importmap = structuredClone(options?.importmap ?? { imports: {}, scopes: {} });
-    importmap.imports ??= {};
-    importmap.scopes ??= {};
-    Object.assign(importmap.imports, builtins);
-    return { importmap, builtins };
-}
-export function importmap(options) {
-    const { importmap, builtins } = createImportMap(options);
-    return {
-        name: "@patchwork/vite",
-        async buildStart() {
-            for (const [id, fileName] of Object.entries(builtins)) {
-                this.emitFile({
-                    type: "chunk",
-                    fileName: fileName.slice(1),
-                    id: await resolveExternal.call(this, id),
-                    preserveSignature: "strict",
-                });
-            }
-            // Emit automerge, keyhive, and subduction wasm so the service worker can fetch them
-            const automergeWasmPath = require.resolve("@automerge/automerge/automerge.wasm");
-            this.emitFile({
-                type: "asset",
-                fileName: "automerge.wasm",
-                source: readFileSync(automergeWasmPath),
-            });
-            const keyhiveWasmPath = require.resolve("@keyhive/keyhive/keyhive_wasm.wasm");
-            this.emitFile({
-                type: "asset",
-                fileName: "keyhive_wasm.wasm",
-                source: readFileSync(keyhiveWasmPath),
-            });
-            // Emit subduction wasm so the service worker can fetch it
-            const subdWasmPath = require.resolve("@automerge/automerge-subduction/wasm");
-            this.emitFile({
-                type: "asset",
-                fileName: "subduction.wasm",
-                source: readFileSync(subdWasmPath),
-            });
-        },
-        async resolveId(id) {
-            if (id in builtins) {
-                // point the site's own imports at the same copy we emit as a chunk,
-                // otherwise rollup bundles a second one out of the site's node_modules
-                // and you end up with two automerges racing to init the same wasm
-                return resolveExternal.call(this, id);
-            }
-            if (id in importmap.imports) {
-                return { id: importmap.imports[id], external: true };
-            }
-        },
-        transformIndexHtml: {
-            order: "pre",
-            handler(html) {
-                return {
-                    html,
-                    tags: [
-                        {
-                            tag: "script",
-                            attrs: { type: "importmap" },
-                            children: JSON.stringify(importmap, null, 2),
-                        },
-                    ],
-                };
-            },
-        },
-    };
-}

package/dist/vite/patchwork-plugin.d.ts

@@ -1,14 +0,0 @@
-export default function patchwork(options?: PatchworkVitePluginOptions): import("vite").Plugin<any>[];
-type Imports = {
-    [name: string]: string;
-};
-export type ImportMap = {
-    imports: Imports;
-    scopes?: {
-        [scope: string]: Imports;
-    };
-};
-export interface PatchworkVitePluginOptions {
-    importmap?: ImportMap;
-}
-export {};

package/dist/vite/patchwork-plugin.js

@@ -1,8 +0,0 @@
-// todo this is now not patchwork-specific, it's just a fun little importmap thing
-// and a separate thing that returns the service worker which doesn't really
-// need to be a plugin at all
-import { importmap } from "./importmap-plugin.js";
-import { serviceworker } from "./service-worker-plugin.js";
-export default function patchwork(options) {
-    return [importmap(options), serviceworker()];
-}

package/dist/vite/service-worker-plugin.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from "vite";
-export declare function serviceworker(): Plugin;

package/dist/vite/service-worker-plugin.js

@@ -1,42 +0,0 @@
-import { builtins } from "./importmap-plugin.js";
-// The service worker and the automerge shared worker are emitted as their
-// own chunks. Their heavy imports are marked external and resolved to
-// /packages/... URLs (both workers are created with type:"module", so the
-// browser fetches those as regular network requests).
-const workers = [
-    {
-        specifier: "@inkandswitch/patchwork-bootloader/service-worker",
-        fileName: "service-worker.js",
-    },
-    {
-        specifier: "@inkandswitch/patchwork-bootloader/automerge-worker",
-        fileName: "automerge-worker.js",
-    },
-    {
-        specifier: "@inkandswitch/patchwork-bootloader/module-loader-worker",
-        fileName: "module-loader-worker.js",
-    },
-];
-export function serviceworker() {
-    const entryIds = new Set();
-    return {
-        name: "@patchwork/service-worker",
-        enforce: "pre",
-        async buildStart() {
-            for (const { specifier, fileName } of workers) {
-                const resolved = await this.resolve(specifier);
-                entryIds.add(resolved.id);
-                this.emitFile({
-                    type: "chunk",
-                    id: resolved.id,
-                    fileName,
-                });
-            }
-        },
-        resolveId(source, importer) {
-            if (importer && entryIds.has(importer) && source in builtins) {
-                return { id: builtins[source], external: true };
-            }
-        },
-    };
-}