@tokamakdev/tok 0.1.1-beta.80 → 0.1.1-beta.82

package/README.md

@@ -11,18 +11,21 @@ npx tok targets
 
 | Entry | Contents |
 | --- | --- |
-| `@tokamakdev/tok` | The `Config` type of `src/tokamak.ts` |
+| `@tokamakdev/tok` | The `Config` type of the Vite plugin's options |
 | `@tokamakdev/tok/vite` | The Vite plugin, `tokamak()` |
 | `tok` | The CLI |
 
-The Vite plugin goes next to Cloudflare's:
+The Vite plugin goes next to Cloudflare's, and its options are the app's
+tokamak configuration:
 
 ```ts
 import { cloudflare } from "@cloudflare/vite-plugin";
 import { tokamak } from "@tokamakdev/tok/vite";
 import { defineConfig } from "vite";
 
-export default defineConfig({ plugins: [cloudflare(), tokamak()] });
+export default defineConfig({
+  plugins: [cloudflare(), tokamak({ name: "My App", version: "1.0.0" })],
+});
 ```
 
 It does nothing unless `tok` runs the build or development command.

package/dist/index.d.mts

@@ -6,18 +6,18 @@ export interface PlatformConfig {
     name?: string;
     /** Application identifier. */
     identifier?: string;
-    /** Icon in the platform's format, relative to the configuration file. */
+    /** Icon in the platform's format, relative to the Vite root. */
     icon?: string;
     /** A setting the platform pack declares; `tok` validates it. */
     [key: string]: Value | undefined;
 }
-/** The app's tokamak configuration, exported as `config` from `src/tokamak.ts`. */
+/** The app's tokamak configuration: the tokamak Vite plugin's options other than `module`. */
 export interface Config {
     /** Display name for every platform. */
     name?: string;
     /** Application identifier for every platform. */
     identifier?: string;
-    /** Icon for every platform, relative to the configuration file. */
+    /** Icon for every platform, relative to the Vite root. */
     icon?: string;
     /** App version. */
     version?: string;

package/dist/vite.d.mts

@@ -1,8 +1,15 @@
 import { type Plugin } from "vite";
+import type { Config } from "./index.mjs";
 /**
- * Reports the build's tokamak configuration, and the development server's
- * address and Worker name, to `tok`, and makes the entry Worker import the
- * configuration file. Without `TOKAMAK_VITE_OUTPUT`, which `tok` sets, it adds
- * no hooks.
+ * Reports the app's tokamak configuration, and the development server's
+ * address, HTTPS certificate and Worker name, to `tok`, and makes the entry
+ * Worker import `module`. Without `TOKAMAK_VITE_OUTPUT`, which `tok` sets, it
+ * adds no hooks.
  */
-export declare function tokamak(): Plugin[];
+export declare function tokamak({ module, ...config }?: Config & {
+    /**
+     * The module the entry Worker imports, relative to the Vite root; by
+     * default `src/tokamak.ts`, then `src/tokamak.js`, when one exists.
+     */
+    module?: string;
+}): Plugin[];

package/dist/vite.mjs

@@ -1,57 +1,53 @@
+import { X509Certificate } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { normalizePath, runnerImport, } from "vite";
-/** Configuration files tried in order when `tok` names none. */
-const CONFIG_FILES = ["src/tokamak.ts", "src/tokamak.js"];
+import { normalizePath } from "vite";
+/** Modules tried in order when the options name none. */
+const DEFAULT_MODULES = ["src/tokamak.ts", "src/tokamak.js"];
 /** Wrangler configuration files Cloudflare's plugin tries in order. */
 const WRANGLER_FILES = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
-/** The files each output directory's `config.json` was read from, once written. */
-const written = new Map();
+const MIDDLEWARE_MODE_ERROR = "Vite is running in middleware mode, so tokamak cannot find the development server's address; tok dev needs Vite's own dev server";
 /**
- * Reports the build's tokamak configuration, and the development server's
- * address and Worker name, to `tok`, and makes the entry Worker import the
- * configuration file. Without `TOKAMAK_VITE_OUTPUT`, which `tok` sets, it adds
- * no hooks.
+ * Reports the app's tokamak configuration, and the development server's
+ * address, HTTPS certificate and Worker name, to `tok`, and makes the entry
+ * Worker import `module`. Without `TOKAMAK_VITE_OUTPUT`, which `tok` sets, it
+ * adds no hooks.
  */
-export function tokamak() {
+export function tokamak({ module, ...config } = {}) {
     const output = process.env.TOKAMAK_VITE_OUTPUT;
     if (!output) {
         return [];
     }
-    let config;
     let file;
     /** The module IDs of each entry environment's inputs. */
     const entryIds = new Map();
-    /** The entry environments whose input imports the configuration file. */
+    /** The entry environments whose input imports the module. */
     const importing = new Set();
-    const write = () => {
-        const files = writeConfig(output, file, config);
-        // A file that fails to load stays watched, so fixing it rewrites `config.json`.
-        written.set(output, files.catch(() => (file ? [file] : [])));
-        return files;
-    };
     return [
         {
             name: "tokamak",
-            async configResolved(resolved) {
-                config = resolved;
-                file = findConfigFile(resolved.root);
-                await (written.has(output) ? written.get(output) : write());
-            },
-            async watchChange(id) {
-                if ((await written.get(output))?.includes(id)) {
-                    await write();
-                }
+            configResolved({ root }) {
+                file = findModule(root, module);
+                writeJson(output, "config.json", { root, config });
             },
             async configureServer(server) {
                 const httpServer = server.httpServer;
+                // A middleware-mode server beside a reported one, such as the server
+                // Astro syncs content with, leaves the report in place.
                 if (!httpServer) {
+                    if (!fs.existsSync(path.join(output, "server.json"))) {
+                        writeJson(output, "server.json", { error: MIDDLEWARE_MODE_ERROR });
+                    }
                     return;
                 }
                 const workerName = await readWorkerName(server.config.root);
                 httpServer.on("listening", () => {
                     const urls = server.resolvedUrls;
-                    writeJson(output, "server.json", { url: urls?.local[0] ?? urls?.network[0], workerName });
+                    writeJson(output, "server.json", {
+                        url: urls?.local[0] ?? urls?.network[0],
+                        workerName,
+                        certificates: endEntityCertificates(server.config.server.https),
+                    });
                 });
             },
             async buildApp(builder) {
@@ -65,9 +61,6 @@ export function tokamak() {
             name: "tokamak:entry",
             applyToEnvironment: ({ config }) => file !== undefined && buildsEntryWorker(config),
             async transform(code, id) {
-                if (id === file) {
-                    return withoutConfig(this, code);
-                }
                 const environment = this.environment;
                 const ids = entryIds.get(environment.name) ??
                     Promise.all(inputs(environment.config.build).map(async (input) => (await this.resolve(input))?.id));
@@ -88,33 +81,14 @@ export function tokamak() {
         },
     ];
 }
-/** The configuration file `TOKAMAK_CONFIG` names, or the first default under `root` that exists. */
-function findConfigFile(root) {
-    const named = process.env.TOKAMAK_CONFIG;
-    if (named) {
-        if (!fs.existsSync(named)) {
-            throw new Error(`tokamak configuration file not found: ${named}`);
-        }
-        return normalizePath(path.resolve(named));
+/** The module `name` under `root`, or else the first default under `root` that exists. */
+function findModule(root, name) {
+    const candidates = (name ? [name] : DEFAULT_MODULES).map((candidate) => normalizePath(path.resolve(root, candidate)));
+    const file = candidates.find((candidate) => fs.existsSync(candidate));
+    if (name && !file) {
+        throw new Error(`tokamak module not found: ${candidates[0]}`);
     }
-    const file = CONFIG_FILES.map((name) => path.resolve(root, name)).find((candidate) => fs.existsSync(candidate));
-    return file && normalizePath(file);
-}
-/**
- * Writes the file's `config` export, with the file's path, to `config.json`,
- * returning the files it was read from.
- */
-async function writeConfig(output, file, config) {
-    if (!file) {
-        writeJson(output, "config.json", { config: {} });
-        return [];
-    }
-    const { module, dependencies } = await runnerImport(file, {
-        root: config.root,
-        resolve: { alias: config.resolve.alias, tsconfigPaths: config.resolve.tsconfigPaths },
-    });
-    writeJson(output, "config.json", { file, config: module.config ?? {} });
-    return [file, ...dependencies.map(normalizePath)];
+    return file;
 }
 /**
  * The name of the Worker in the Wrangler configuration file in `root`, found
@@ -130,6 +104,22 @@ async function readWorkerName(root) {
     const worker = unstable_readConfig({ config: file, env: process.env.CLOUDFLARE_ENV }, { hideWarnings: true });
     return worker.topLevelName ?? worker.name;
 }
+/**
+ * The PEM of the end-entity certificate of each chain in `https.cert`, which
+ * Vite reads from a file when a string names one.
+ */
+function endEntityCertificates(https) {
+    const cert = typeof https?.cert === "string" ? readFileIfExists(https.cert) : https?.cert;
+    return cert && [cert].flat().map((chain) => new X509Certificate(chain).toString()).join("");
+}
+function readFileIfExists(file) {
+    try {
+        return fs.readFileSync(path.resolve(file));
+    }
+    catch {
+        return file;
+    }
+}
 /**
  * Whether an environment builds from the entry Worker: Cloudflare's plugin
  * gives a manifest to its entry and prerender Workers, and Astro to its server
@@ -143,50 +133,6 @@ function inputs(build) {
     const { input } = build.rollupOptions;
     return typeof input === "string" ? [input] : Object.values(input ?? {});
 }
-/**
- * `code` without its `config` export: the `export const config = ...`
- * statement is blanked, or only its `export` keyword while other statements
- * mention `config`, so that every other position, and so the source map, is
- * unchanged.
- */
-function withoutConfig(context, code) {
-    const statements = context.parse(code).body;
-    const statement = statements.find(exportsConfig);
-    if (!statement) {
-        return;
-    }
-    const declaration = statement.declaration;
-    if (declaration?.declarations?.length !== 1) {
-        return context.error("declare config in its own `export const config = ...` statement");
-    }
-    const mentioned = statements.some((other) => other !== statement && mentions(other, "config"));
-    const end = mentioned ? declaration.start : statement.end;
-    const blank = code.slice(statement.start, end).replace(/[^\n]/g, " ");
-    return { code: code.slice(0, statement.start) + blank + code.slice(end), map: null };
-}
-/** Whether `node` contains an identifier named `name`, property names included. */
-function mentions(node, name) {
-    if (typeof node !== "object" || node === null) {
-        return false;
-    }
-    const identifier = node;
-    if (identifier.type === "Identifier" && identifier.name === name) {
-        return true;
-    }
-    return Object.values(node).some((child) => mentions(child, name));
-}
-function exportsConfig(statement) {
-    if (statement.type !== "ExportNamedDeclaration") {
-        return false;
-    }
-    const declaration = statement.declaration;
-    const names = [
-        declaration?.id?.name,
-        ...(declaration?.declarations ?? []).map((declarator) => declarator.id.name),
-        ...(statement.specifiers ?? []).map((specifier) => specifier.exported.name),
-    ];
-    return names.includes("config");
-}
 /** Writes `value` to `name` whole, as `tok` reads the file as soon as it exists. */
 function writeJson(output, name, value) {
     const file = path.join(output, name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/tok",
-  "version": "0.1.1-beta.80",
+  "version": "0.1.1-beta.82",
   "description": "The tokamak CLI, Vite plugin and app API: build native apps from a Cloudflare Workers codebase",
   "repository": {
     "type": "git",
@@ -55,17 +55,17 @@
     "wrangler": "4.147.0"
   },
   "optionalDependencies": {
-    "@tokamakdev/platform-android-arm64": "0.1.1-beta.80",
-    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.80",
-    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.80",
-    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.80",
-    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.80",
-    "@tokamakdev/platform-macos-x64": "0.1.1-beta.80",
-    "@tokamakdev/platform-windows-x64": "0.1.1-beta.80",
-    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.80",
-    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.80",
-    "@tokamakdev/tok-linux-x64": "0.1.1-beta.80",
-    "@tokamakdev/tok-win32-x64": "0.1.1-beta.80"
+    "@tokamakdev/platform-android-arm64": "0.1.1-beta.82",
+    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.82",
+    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.82",
+    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.82",
+    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.82",
+    "@tokamakdev/platform-macos-x64": "0.1.1-beta.82",
+    "@tokamakdev/platform-windows-x64": "0.1.1-beta.82",
+    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.82",
+    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.82",
+    "@tokamakdev/tok-linux-x64": "0.1.1-beta.82",
+    "@tokamakdev/tok-win32-x64": "0.1.1-beta.82"
   },
   "publishConfig": {
     "access": "public"