@gtkx/cli 1.0.0-rc.3 → 1.0.0

package/src/vite-plugins/worker.ts

@@ -0,0 +1,235 @@
+import type { Plugin, Rollup } from "vite";
+import { createHash } from "node:crypto";
+import { basename, extname } from "node:path";
+import { stripQuery } from "./strip-query.js";
+
+type WorkerReplacement = {
+    start: number;
+    end: number;
+    fileName: string;
+};
+
+type EmitContext = {
+    context: Rollup.PluginContext;
+    emitted: Map<string, string>;
+};
+
+type SourceRange = {
+    start: number;
+    end: number;
+};
+
+type ScanContext = {
+    code: string;
+    id: string;
+    nonCode: SourceRange[];
+};
+
+type HoistedWorkerUrl = {
+    name: string;
+    specifier: string;
+};
+
+type TransformResult = {
+    code: string;
+    map: null;
+} | null;
+
+const RELATIVE_SPECIFIER = String.raw`(?<quote>["'])(?<specifier>\.{1,2}\/[^"']+)\k<quote>`;
+const URL_CALL = String.raw`new\s+URL\s*\(\s*${RELATIVE_SPECIFIER}\s*,\s*import\.meta\.url\s*\)`;
+const URL_DECLARATION = String.raw`(?:const|let|var)\s+(?<name>[A-Za-z_$][\w$]*)\s*(?::[^=;\n]+)?=\s*`;
+const BLOCK_COMMENT = String.raw`\/\*[\s\S]*?\*\/`;
+const LINE_COMMENT = String.raw`\/\/[^\n]*`;
+const DOUBLE_QUOTED = String.raw`"(?:[^"\\\n]|\\[\s\S])*"`;
+const SINGLE_QUOTED = String.raw`'(?:[^'\\\n]|\\[\s\S])*'`;
+const TEMPLATE_LITERAL = String.raw`\`(?:[^\`\\]|\\[\s\S])*\``;
+const WORKER_URL = new RegExp(URL_CALL, "g");
+const HOISTED_WORKER_URL = new RegExp(URL_DECLARATION + URL_CALL, "g");
+const WORKER_CONSTRUCTION = /new\s+(?:\w+\.)?Worker\s*\(\s*$/;
+
+const NON_CODE = new RegExp(
+    [BLOCK_COMMENT, LINE_COMMENT, DOUBLE_QUOTED, SINGLE_QUOTED, TEMPLATE_LITERAL].join("|"),
+    "g",
+);
+
+const SUGGESTED_EXTENSIONS: Record<string, string[]> = {
+    ".cjs": [".cts"],
+    ".js": [".ts", ".tsx"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts"],
+};
+
+const workerFileName = (id: string): string => {
+    const path = stripQuery(id);
+    const stem = basename(path, extname(path));
+    const digest = createHash("sha256").update(id).digest("hex").slice(0, 8);
+
+    return `workers/${stem}-${digest}.js`;
+};
+
+const nonCodeRanges = (code: string): SourceRange[] =>
+    code
+        .matchAll(NON_CODE)
+        .map((match) => ({ start: match.index, end: match.index + match[0].length }))
+        .toArray();
+
+const isCodePosition = (scan: ScanContext, index: number): boolean =>
+    scan.nonCode.every((range) => index < range.start || index >= range.end);
+
+const isWorkerConstruction = (code: string, matchIndex: number): boolean =>
+    WORKER_CONSTRUCTION.test(code.slice(0, matchIndex));
+
+const hasWorkerCandidate = (code: string): boolean => code.includes("import.meta.url") && code.includes("Worker");
+
+const workerUrlExpression = (fileName: string): string => {
+    const specifier = JSON.stringify(`./${fileName}`);
+
+    return `new URL(${specifier}, import.meta.url)`;
+};
+
+const inlineWorkerExample = (specifier: string): string =>
+    `new Worker(new URL(${JSON.stringify(specifier)}, import.meta.url))`;
+
+const hoistedWorkerError = (scan: ScanContext, hoisted: HoistedWorkerUrl): Error =>
+    new Error(
+        `${stripQuery(scan.id)}: the worker URL for ${JSON.stringify(hoisted.specifier)} is bound to ` +
+        `"${hoisted.name}" before it reaches "new Worker". gtkx build emits a worker chunk only for a URL ` +
+        `written inside the construction. Write ${inlineWorkerExample(hoisted.specifier)} instead.`,
+    );
+
+const unresolvedWorkerError = (scan: ScanContext, specifier: string, suggestion: string | null): Error =>
+    new Error(
+        `${stripQuery(scan.id)}: the worker specifier ${JSON.stringify(specifier)} does not resolve to a module, ` +
+        "so no worker chunk can be emitted. " +
+        (suggestion === null
+            ? "Correct the path so it names the worker source file as it exists on disk."
+            : `Write ${inlineWorkerExample(suggestion)} instead.`),
+    );
+
+const suggestionFor = async (emit: EmitContext, scan: ScanContext, specifier: string): Promise<string | null> => {
+    const extension = extname(specifier);
+    const stem = specifier.slice(0, specifier.length - extension.length);
+    const candidates = SUGGESTED_EXTENSIONS[extension] ?? [];
+
+    for (const candidate of candidates) {
+        const resolved = await emit.context.resolve(stem + candidate, scan.id);
+
+        if (resolved !== null) {
+            return stem + candidate;
+        }
+    }
+
+    return null;
+};
+
+const claimWorker = (emit: EmitContext, resolvedId: string): string => {
+    const existing = emit.emitted.get(resolvedId);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    const fileName = workerFileName(resolvedId);
+    emit.emitted.set(resolvedId, fileName);
+    emit.context.emitFile({ type: "chunk", id: resolvedId, fileName });
+
+    return fileName;
+};
+
+const isRewritableUrl = (scan: ScanContext, match: RegExpExecArray): boolean =>
+    isCodePosition(scan, match.index) && isWorkerConstruction(scan.code, match.index);
+
+const replacementFor = async (
+    emit: EmitContext,
+    scan: ScanContext,
+    match: RegExpExecArray,
+): Promise<WorkerReplacement | null> => {
+    const specifier = match.groups?.specifier;
+
+    if (specifier === undefined || !isRewritableUrl(scan, match)) {
+        return null;
+    }
+
+    const resolved = await emit.context.resolve(specifier, scan.id);
+
+    if (resolved === null) {
+        throw unresolvedWorkerError(scan, specifier, await suggestionFor(emit, scan, specifier));
+    }
+
+    return { start: match.index, end: match.index + match[0].length, fileName: claimWorker(emit, resolved.id) };
+};
+
+const collectReplacements = async (emit: EmitContext, scan: ScanContext): Promise<WorkerReplacement[]> => {
+    const pending = scan.code.matchAll(WORKER_URL).map((match) => replacementFor(emit, scan, match)).toArray();
+    const found = await Promise.all(pending);
+
+    return found.filter((entry) => entry !== null);
+};
+
+const hasWorkerArgument = (scan: ScanContext, name: string): boolean => {
+    const escaped = name.replaceAll("$", String.raw`\$`);
+    const pattern = new RegExp(String.raw`new\s+(?:\w+\.)?Worker\s*\(\s*${escaped}\s*[,)]`, "g");
+
+    return scan.code.matchAll(pattern).some((match) => isCodePosition(scan, match.index));
+};
+
+const hoistedUrlFor = (scan: ScanContext, match: RegExpExecArray): HoistedWorkerUrl | null => {
+    const name = match.groups?.name;
+    const specifier = match.groups?.specifier;
+
+    if (name === undefined || specifier === undefined || !isCodePosition(scan, match.index)) {
+        return null;
+    }
+
+    return { name, specifier };
+};
+
+const findHoistedWorkerUrl = (scan: ScanContext): HoistedWorkerUrl | null =>
+    scan.code
+        .matchAll(HOISTED_WORKER_URL)
+        .map((match) => hoistedUrlFor(scan, match))
+        .find((entry) => entry !== null && hasWorkerArgument(scan, entry.name)) ?? null;
+
+const applyReplacements = (code: string, replacements: WorkerReplacement[]): string => {
+    let output = "";
+    let cursor = 0;
+
+    for (const { start, end, fileName } of replacements) {
+        output += code.slice(cursor, start) + workerUrlExpression(fileName);
+        cursor = end;
+    }
+
+    return output + code.slice(cursor);
+};
+
+const transformWorkerUrls = async (emit: EmitContext, code: string, id: string): Promise<TransformResult> => {
+    if (!hasWorkerCandidate(code)) {
+        return null;
+    }
+
+    const scan: ScanContext = { code, id, nonCode: nonCodeRanges(code) };
+    const hoisted = findHoistedWorkerUrl(scan);
+
+    if (hoisted !== null) {
+        throw hoistedWorkerError(scan, hoisted);
+    }
+
+    const replacements = await collectReplacements(emit, scan);
+
+    return replacements.length === 0 ? null : { code: applyReplacements(code, replacements), map: null };
+};
+
+function gtkxWorker(): Plugin {
+    const emitted: Map<string, string> = new Map();
+
+    return {
+        name: "gtkx:worker",
+        apply: "build",
+
+        transform(code, id) {
+            return transformWorkerUrls({ context: this, emitted }, code, id);
+        },
+    };
+}
+
+export { gtkxWorker };

package/src/vitest-plugin.ts

@@ -1,13 +1,21 @@
 import type { Plugin } from "vite";
 import gtkxVitest from "@gtkx/vitest";
+import { gtkxEnsureStore } from "./vite-plugins/ensure-store.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
 
 /**
- * Vite plugin factory that assembles the plugins needed to run GTKX apps under Vitest,
- * combining the shared GTKX Vite plugins with the `@gtkx/vitest` test integration.
+ * Vite plugin stack for testing a GTKX application: the generated bindings the tests import,
+ * the plugins the app is built with, the project's compiled GSettings schemas exposed to every
+ * test worker, and a headless display per worker.
  *
- * @returns The ordered array of Vite plugins to include in a Vitest configuration.
+ * @returns The plugins to spread into a Vitest config.
  */
-const gtkx = (): Plugin[] => [...gtkxVitePlugins(), gtkxSettingsWorkerEnv(), gtkxVitest()];
+const gtkx = (): Plugin[] => [
+    gtkxEnsureStore(),
+    ...gtkxVitePlugins(),
+    gtkxSettingsWorkerEnv(),
+    gtkxVitest(),
+];
+
 export default gtkx;

package/dist/internal/resolve-cli-tool.d.ts

@@ -1,3 +0,0 @@
-declare const resolveCliTool: (executable: string) => string;
-export { resolveCliTool };
-//# sourceMappingURL=resolve-cli-tool.d.ts.map

package/dist/internal/resolve-cli-tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-cli-tool.d.ts","sourceRoot":"","sources":["../../src/internal/resolve-cli-tool.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,cAAc,eAGI,MAAM,KAAG,MAY7B,CAAC;AAkBL,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/internal/resolve-cli-tool.js

@@ -1,27 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-const resolveCliTool = (() => {
-    const cache = new Map();
-    return (executable) => {
-        const cached = cache.get(executable);
-        if (cached) {
-            return cached;
-        }
-        const resolved = findInPath(executable);
-        cache.set(executable, resolved);
-        return resolved;
-    };
-})();
-const isExecutableFile = (candidate) => existsSync(candidate) && statSync(candidate).isFile();
-const findInPath = (executable) => {
-    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-    for (const dir of dirs) {
-        const candidate = join(dir, executable);
-        if (isExecutableFile(candidate)) {
-            return candidate;
-        }
-    }
-    throw new Error(`${executable} not found in PATH`);
-};
-export { resolveCliTool };
-//# sourceMappingURL=resolve-cli-tool.js.map

package/dist/internal/resolve-cli-tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-cli-tool.js","sourceRoot":"","sources":["../../src/internal/resolve-cli-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE;IACzB,MAAM,KAAK,GAAwB,IAAI,GAAG,EAAE,CAAC;IAE7C,OAAO,CAAC,UAAkB,EAAU,EAAE;QAClC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAErC,IAAI,MAAM,EAAE,CAAC;YACT,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACxC,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAEhC,OAAO,QAAQ,CAAC;IACpB,CAAC,CAAC;AACN,CAAC,CAAC,EAAE,CAAC;AAEL,MAAM,gBAAgB,GAAG,CAAC,SAAiB,EAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;AAE/G,MAAM,UAAU,GAAG,CAAC,UAAkB,EAAU,EAAE;IAC9C,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEvE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACrB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAExC,IAAI,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC;QACrB,CAAC;IACL,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,GAAG,UAAU,oBAAoB,CAAC,CAAC;AACvD,CAAC,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["import { existsSync, statSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\n\nconst resolveCliTool = (() => {\n    const cache: Map<string, string> = new Map();\n\n    return (executable: string): string => {\n        const cached = cache.get(executable);\n\n        if (cached) {\n            return cached;\n        }\n\n        const resolved = findInPath(executable);\n        cache.set(executable, resolved);\n\n        return resolved;\n    };\n})();\n\nconst isExecutableFile = (candidate: string): boolean => existsSync(candidate) && statSync(candidate).isFile();\n\nconst findInPath = (executable: string): string => {\n    const dirs = (process.env.PATH ?? \"\").split(delimiter).filter(Boolean);\n\n    for (const dir of dirs) {\n        const candidate = join(dir, executable);\n\n        if (isExecutableFile(candidate)) {\n            return candidate;\n        }\n    }\n\n    throw new Error(`${executable} not found in PATH`);\n};\n\nexport { resolveCliTool };\n"]}

package/src/internal/resolve-cli-tool.ts

@@ -1,37 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-
-const resolveCliTool = (() => {
-    const cache: Map<string, string> = new Map();
-
-    return (executable: string): string => {
-        const cached = cache.get(executable);
-
-        if (cached) {
-            return cached;
-        }
-
-        const resolved = findInPath(executable);
-        cache.set(executable, resolved);
-
-        return resolved;
-    };
-})();
-
-const isExecutableFile = (candidate: string): boolean => existsSync(candidate) && statSync(candidate).isFile();
-
-const findInPath = (executable: string): string => {
-    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-
-    for (const dir of dirs) {
-        const candidate = join(dir, executable);
-
-        if (isExecutableFile(candidate)) {
-            return candidate;
-        }
-    }
-
-    throw new Error(`${executable} not found in PATH`);
-};
-
-export { resolveCliTool };