@b9g/shovel 0.2.0-beta.10 → 0.2.0-beta.11

package/chunk-ILQUUH2L.js

@@ -1,164 +0,0 @@
-// src/utils/import-meta-plugin.ts
-import { readFile } from "fs/promises";
-import { dirname } from "path";
-import { pathToFileURL } from "url";
-function importMetaPlugin() {
-  return {
-    name: "import-meta-transform",
-    setup(build) {
-      build.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
-        if (args.path.includes("node_modules")) {
-          return null;
-        }
-        const contents = await readFile(args.path, "utf8");
-        if (!contents.includes("import.meta.url") && !contents.includes("import.meta.dirname") && !contents.includes("import.meta.filename")) {
-          return null;
-        }
-        const fileUrl = pathToFileURL(args.path).href;
-        const fileDirname = dirname(args.path);
-        const fileFilename = args.path;
-        let transformed = contents;
-        transformed = transformed.replace(
-          /\bimport\.meta\.url\b/g,
-          JSON.stringify(fileUrl)
-        );
-        transformed = transformed.replace(
-          /\bimport\.meta\.dirname\b/g,
-          JSON.stringify(fileDirname)
-        );
-        transformed = transformed.replace(
-          /\bimport\.meta\.filename\b/g,
-          JSON.stringify(fileFilename)
-        );
-        const ext = args.path.split(".").pop();
-        let loader = "js";
-        if (ext === "ts")
-          loader = "ts";
-        else if (ext === "tsx")
-          loader = "tsx";
-        else if (ext === "jsx")
-          loader = "jsx";
-        return {
-          contents: transformed,
-          loader
-        };
-      });
-    }
-  };
-}
-
-// src/utils/jsx-config.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join, dirname as dirname2 } from "path";
-import { existsSync } from "fs";
-var CRANK_JSX_DEFAULTS = {
-  jsx: "automatic",
-  jsxImportSource: "@b9g/crank"
-};
-async function findTsConfig(startDir) {
-  let dir = startDir;
-  while (dir !== dirname2(dir)) {
-    const tsconfigPath = join(dir, "tsconfig.json");
-    if (existsSync(tsconfigPath)) {
-      return tsconfigPath;
-    }
-    dir = dirname2(dir);
-  }
-  return null;
-}
-async function parseTsConfig(tsconfigPath) {
-  const content = await readFile2(tsconfigPath, "utf8");
-  const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-  const config = JSON.parse(stripped);
-  if (config.extends) {
-    const baseDir = dirname2(tsconfigPath);
-    let extendsPath = config.extends;
-    if (extendsPath.startsWith(".")) {
-      extendsPath = join(baseDir, extendsPath);
-    } else {
-      extendsPath = join(baseDir, "node_modules", extendsPath);
-    }
-    if (!extendsPath.endsWith(".json")) {
-      extendsPath += ".json";
-    }
-    if (existsSync(extendsPath)) {
-      const baseConfig = await parseTsConfig(extendsPath);
-      return {
-        ...baseConfig,
-        ...config,
-        compilerOptions: {
-          ...baseConfig.compilerOptions,
-          ...config.compilerOptions
-        }
-      };
-    }
-  }
-  return config;
-}
-function mapTSConfigToESBuild(compilerOptions) {
-  const options = {};
-  if (compilerOptions.jsx) {
-    switch (compilerOptions.jsx) {
-      case "react":
-      case "react-native":
-        options.jsx = "transform";
-        break;
-      case "react-jsx":
-      case "react-jsxdev":
-        options.jsx = "automatic";
-        break;
-      case "preserve":
-        options.jsx = "preserve";
-        break;
-    }
-  }
-  if (compilerOptions.jsxFactory) {
-    options.jsxFactory = compilerOptions.jsxFactory;
-  }
-  if (compilerOptions.jsxFragmentFactory) {
-    options.jsxFragment = compilerOptions.jsxFragmentFactory;
-  }
-  if (compilerOptions.jsxImportSource) {
-    options.jsxImportSource = compilerOptions.jsxImportSource;
-  }
-  return options;
-}
-async function loadJSXConfig(projectRoot) {
-  const tsconfigPath = await findTsConfig(projectRoot);
-  if (tsconfigPath) {
-    const config = await parseTsConfig(tsconfigPath);
-    const compilerOptions = config.compilerOptions || {};
-    const hasJSXConfig = compilerOptions.jsx || compilerOptions.jsxFactory || compilerOptions.jsxFragmentFactory || compilerOptions.jsxImportSource;
-    if (hasJSXConfig) {
-      const tsOptions = mapTSConfigToESBuild(compilerOptions);
-      return {
-        ...CRANK_JSX_DEFAULTS,
-        ...tsOptions
-      };
-    }
-  }
-  return { ...CRANK_JSX_DEFAULTS };
-}
-function applyJSXOptions(buildOptions, jsxOptions) {
-  if (jsxOptions.jsx) {
-    buildOptions.jsx = jsxOptions.jsx;
-  }
-  if (jsxOptions.jsxFactory) {
-    buildOptions.jsxFactory = jsxOptions.jsxFactory;
-  }
-  if (jsxOptions.jsxFragment) {
-    buildOptions.jsxFragment = jsxOptions.jsxFragment;
-  }
-  if (jsxOptions.jsxImportSource) {
-    buildOptions.jsxImportSource = jsxOptions.jsxImportSource;
-  }
-  if (jsxOptions.jsxSideEffects !== void 0) {
-    buildOptions.jsxSideEffects = jsxOptions.jsxSideEffects;
-  }
-}
-
-export {
-  importMetaPlugin,
-  loadJSXConfig,
-  applyJSXOptions
-};

package/develop-5ORIPB7M.js

@@ -1,264 +0,0 @@
-import {
-  applyJSXOptions,
-  importMetaPlugin,
-  loadJSXConfig
-} from "./chunk-ILQUUH2L.js";
-import {
-  DEFAULTS,
-  findProjectRoot,
-  generateConfigModule,
-  loadRawConfig
-} from "./chunk-CSH7M4MK.js";
-
-// src/commands/develop.ts
-import { getLogger as getLogger2 } from "@logtape/logtape";
-import * as Platform from "@b9g/platform";
-
-// src/utils/watcher.ts
-import * as ESBuild from "esbuild";
-import { resolve, join } from "path";
-import { mkdir } from "fs/promises";
-import { assetsPlugin } from "@b9g/assets/plugin";
-import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["build"]);
-function createConfigPlugin(projectRoot) {
-  const rawConfig = loadRawConfig(projectRoot);
-  const configModuleCode = generateConfigModule(rawConfig);
-  return {
-    name: "shovel-config",
-    setup(build2) {
-      build2.onResolve({ filter: /^shovel:config$/ }, (args) => ({
-        path: args.path,
-        namespace: "shovel-config"
-      }));
-      build2.onLoad({ filter: /.*/, namespace: "shovel-config" }, () => ({
-        contents: configModuleCode,
-        loader: "js",
-        resolveDir: projectRoot
-      }));
-    }
-  };
-}
-async function buildWorker(projectRoot, outputDir) {
-  const workerDestPath = join(outputDir, "server", "worker.js");
-  const virtualWorkerEntry = `
-import {configureLogging} from "@b9g/platform/runtime";
-import {config} from "shovel:config";
-await configureLogging(config.logging);
-
-// Import the actual worker (runs its initialization code)
-import "@b9g/platform/worker";
-`;
-  await ESBuild.build({
-    stdin: {
-      contents: virtualWorkerEntry,
-      resolveDir: projectRoot,
-      sourcefile: "virtual-worker-entry.js"
-    },
-    bundle: true,
-    format: "esm",
-    target: "es2022",
-    platform: "node",
-    outfile: workerDestPath,
-    external: ["node:*"],
-    plugins: [createConfigPlugin(projectRoot)]
-  });
-  logger.info("Built worker", { workerDestPath });
-}
-var Watcher = class {
-  #options;
-  #ctx;
-  #projectRoot;
-  #initialBuildComplete;
-  #initialBuildResolve;
-  #currentEntrypoint;
-  constructor(options) {
-    this.#options = options;
-    this.#projectRoot = findProjectRoot();
-    this.#initialBuildComplete = false;
-    this.#currentEntrypoint = "";
-  }
-  /**
-   * Start watching and building
-   * @returns Result with success status and the hashed entrypoint path
-   */
-  async start() {
-    const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
-    const outputDir = resolve(this.#projectRoot, this.#options.outDir);
-    await mkdir(join(outputDir, "server"), { recursive: true });
-    await mkdir(join(outputDir, "static"), { recursive: true });
-    await buildWorker(this.#projectRoot, outputDir);
-    const jsxOptions = await loadJSXConfig(this.#projectRoot);
-    const initialBuildPromise = new Promise((resolve2) => {
-      this.#initialBuildResolve = resolve2;
-    });
-    const buildOptions = {
-      entryPoints: [entryPath],
-      bundle: true,
-      format: "esm",
-      target: "es2022",
-      platform: "node",
-      outdir: `${outputDir}/server`,
-      entryNames: "[name]-[hash]",
-      metafile: true,
-      absWorkingDir: this.#projectRoot,
-      plugins: [
-        importMetaPlugin(),
-        assetsPlugin({
-          outDir: outputDir,
-          clientBuild: {
-            jsx: jsxOptions.jsx,
-            jsxFactory: jsxOptions.jsxFactory,
-            jsxFragment: jsxOptions.jsxFragment,
-            jsxImportSource: jsxOptions.jsxImportSource
-          }
-        }),
-        // Plugin to detect build completion (works with watch mode)
-        {
-          name: "build-notify",
-          setup: (build2) => {
-            build2.onStart(() => {
-              logger.info("Building", {
-                entrypoint: this.#options.entrypoint
-              });
-            });
-            build2.onEnd(async (result) => {
-              let success = result.errors.length === 0;
-              const dynamicImportWarnings = (result.warnings || []).filter(
-                (w) => w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")
-              );
-              if (dynamicImportWarnings.length > 0) {
-                success = false;
-                for (const warning of dynamicImportWarnings) {
-                  const loc = warning.location;
-                  const file = loc?.file || "unknown";
-                  const line = loc?.line || "?";
-                  logger.error(
-                    "Non-analyzable dynamic import at {file}:{line}: {text}",
-                    { file, line, text: warning.text }
-                  );
-                }
-                logger.error(
-                  "Dynamic imports must use literal strings, not variables. For config-driven providers, ensure they are registered in shovel.json."
-                );
-              }
-              let outputPath = "";
-              if (result.metafile) {
-                const outputs = Object.keys(result.metafile.outputs);
-                const jsOutput = outputs.find((p) => p.endsWith(".js"));
-                if (jsOutput) {
-                  outputPath = resolve(this.#projectRoot, jsOutput);
-                }
-              }
-              if (success) {
-                logger.info("Build complete", { entrypoint: outputPath });
-              } else {
-                logger.error("Build errors: {errors}", { errors: result.errors });
-              }
-              this.#currentEntrypoint = outputPath;
-              if (!this.#initialBuildComplete) {
-                this.#initialBuildComplete = true;
-                this.#initialBuildResolve?.({ success, entrypoint: outputPath });
-              } else {
-                await this.#options.onBuild?.(success, outputPath);
-              }
-            });
-          }
-        }
-      ],
-      sourcemap: "inline",
-      minify: false,
-      treeShaking: true
-    };
-    applyJSXOptions(buildOptions, jsxOptions);
-    this.#ctx = await ESBuild.context(buildOptions);
-    logger.info("Starting esbuild watch mode");
-    await this.#ctx.watch();
-    return initialBuildPromise;
-  }
-  /**
-   * Stop watching and dispose of esbuild context
-   */
-  async stop() {
-    if (this.#ctx) {
-      await this.#ctx.dispose();
-      this.#ctx = void 0;
-    }
-  }
-};
-
-// src/commands/develop.ts
-var logger2 = getLogger2(["cli"]);
-async function developCommand(entrypoint, options, config) {
-  try {
-    const platformName = Platform.resolvePlatform({ ...options, config });
-    const workerCount = getWorkerCount(options, config);
-    if (options.verbose) {
-      logger2.info("Platform: {platform}", { platform: platformName });
-      logger2.info("Worker count: {workerCount}", { workerCount });
-    }
-    const platformInstance = await Platform.createPlatform(platformName, {
-      port: parseInt(options.port || String(DEFAULTS.SERVER.PORT), 10),
-      host: options.host || DEFAULTS.SERVER.HOST
-    });
-    logger2.info("Starting development server");
-    logger2.info("Workers: {workerCount}", { workerCount });
-    let serviceWorker;
-    const outDir = "dist";
-    const watcher = new Watcher({
-      entrypoint,
-      outDir,
-      onBuild: async (success, builtEntrypoint2) => {
-        if (success && serviceWorker) {
-          logger2.info("Reloading Workers with {entrypoint}", {
-            entrypoint: builtEntrypoint2
-          });
-          if (platformInstance && typeof platformInstance.reloadWorkers === "function") {
-            await platformInstance.reloadWorkers(builtEntrypoint2);
-          }
-          logger2.info("Workers reloaded");
-        }
-      }
-    });
-    const { success: buildSuccess, entrypoint: builtEntrypoint } = await watcher.start();
-    if (!buildSuccess) {
-      logger2.error("Initial build failed, watching for changes to retry");
-    }
-    serviceWorker = await platformInstance.loadServiceWorker(builtEntrypoint, {
-      hotReload: true,
-      workerCount
-    });
-    const server = platformInstance.createServer(serviceWorker.handleRequest, {
-      port: parseInt(options.port || String(DEFAULTS.SERVER.PORT), 10),
-      host: options.host || DEFAULTS.SERVER.HOST
-    });
-    await server.listen();
-    logger2.info("Server running at {url}", {
-      url: `http://${options.host}:${options.port}`
-    });
-    logger2.info("Serving {entrypoint}", { entrypoint });
-    const shutdown = async (signal) => {
-      logger2.info("Shutting down gracefully ({signal})", { signal });
-      await watcher.stop();
-      await serviceWorker?.dispose();
-      await platformInstance.dispose();
-      await server.close();
-      logger2.info("Shutdown complete");
-      process.exit(0);
-    };
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-  } catch (error) {
-    logger2.error("Failed to start development server: {error}", { error });
-    process.exit(1);
-  }
-}
-function getWorkerCount(options, config) {
-  if (options.workers) {
-    return parseInt(options.workers, 10);
-  }
-  return config?.workers ?? DEFAULTS.WORKERS;
-}
-export {
-  developCommand
-};