bakit 2.0.0-alpha.3 → 2.0.0-alpha.30

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { config } from 'dotenv';
+import { program } from 'commander';
+import { fork } from 'child_process';
+import chokidar from 'chokidar';
+import { loadConfig, RPC } from 'bakit';
+
+var DevProcessManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  rpc = null;
+  restartTimer = null;
+  start() {
+    console.log("Starting bakit in dev mode..."), this.startChild(), this.startWatcher();
+  }
+  startChild() {
+    if (this.rpc)
+      return;
+    let { entryFile } = this.options, child = fork(this.options.entryFile, {
+      execArgv: ["--import", "bakit/register"],
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NODE_ENV: "development",
+        BAKIT_ENTRY_FILE: entryFile
+      }
+    });
+    this.rpc = new RPC(child), this.rpc.on("restart", (fileUpdated) => this.scheduleRestart(fileUpdated));
+  }
+  restartChild() {
+    if (!this.rpc)
+      return this.startChild();
+    let child = this.rpc.transport;
+    child.once("exit", () => {
+      this.rpc = null, this.startChild();
+    }), child.kill("SIGTERM");
+  }
+  startWatcher() {
+    let { entryDirectory } = this.options, watcher = chokidar.watch(entryDirectory, {
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 50
+      }
+    });
+    watcher.on("change", (path) => this.onFileUpdate("fileChange", path)), watcher.on("unlink", (path) => this.onFileUpdate("fileRemove", path));
+  }
+  onFileUpdate(type, path) {
+    try {
+      this.rpc?.send(type, resolve(path));
+    } catch {
+      this.scheduleRestart(true);
+    }
+  }
+  scheduleRestart(fileUpdated = false) {
+    this.restartTimer && clearTimeout(this.restartTimer), this.restartTimer = setTimeout(() => {
+      fileUpdated && console.log("File changes detected, restarting..."), this.restartChild(), this.restartTimer = null;
+    }, 150);
+  }
+};
+program.name("bakit");
+program.command("dev").action(async () => {
+  config({ path: [".env.local", ".env"], quiet: true });
+  let config$1 = await loadConfig(), entryDirectory = resolve(config$1.entryDirectory);
+  new DevProcessManager({
+    entryFile: getEntryFile(entryDirectory),
+    entryDirectory
+  }).start();
+});
+function getEntryFile(entryDirectory) {
+  let index = join(entryDirectory, "index");
+  return existsSync(index + ".ts") ? index : index + ".js";
+}
+program.parse();

package/dist/hooks.js

@@ -0,0 +1,82 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { Module } from 'module';
+import { dirname, resolve as resolve$1, basename } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { RPC } from 'bakit';
+
+// src/lib/loader/hooks.ts
+var EXTENSIONS = [".js", ".ts"], rpc, versions, esbuild;
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+async function initialize({ port }) {
+  rpc = new RPC(port), versions = /* @__PURE__ */ new Map(), rpc.on("unload", onUnload), isDevelopment() && (esbuild = await import('esbuild'));
+}
+async function resolve(specifier, context, nextResolve) {
+  if (shouldSkip(specifier))
+    return nextResolve(specifier, context);
+  let url = specifier, parentURL = context.parentURL?.split("?")[0], baseDir = parentURL ? dirname(fileURLToPath(parentURL)) : process.cwd();
+  if (specifier.startsWith(".")) {
+    let absPath = resolve$1(baseDir, specifier);
+    if (!existsSync(absPath) && absPath.endsWith(".js")) {
+      let tsPath = absPath.slice(0, -3) + ".ts";
+      existsSync(tsPath) && (absPath = tsPath);
+    }
+    url = pathToFileURL(absPath).href;
+  }
+  let urlObj = new URL(url);
+  if (isDevelopment()) {
+    let filePath = fileURLToPath(urlObj), version = createVersion(filePath);
+    urlObj.searchParams.set("hmr", version), parentURL && rpc.send("dependencyAdd", {
+      parentURL,
+      url
+    });
+  }
+  return {
+    url: urlObj.href,
+    shortCircuit: true,
+    format: "module"
+  };
+}
+async function load(url, context, nextLoad) {
+  if (shouldSkip(url))
+    return nextLoad(url, context);
+  try {
+    let cleanURL = url.split("?")[0], filePath = fileURLToPath(cleanURL ?? "");
+    if (filePath.endsWith(".ts") && esbuild) {
+      let raw = await readFile(filePath, "utf8");
+      return {
+        source: (await esbuild.transform(raw, {
+          platform: "node",
+          sourcefile: filePath,
+          sourcemap: "inline",
+          loader: "ts"
+        })).code,
+        format: "module",
+        shortCircuit: !0
+      };
+    }
+  } catch {
+  }
+  return nextLoad(url, context);
+}
+function createVersion(filename) {
+  let version = versions.get(filename);
+  return version || (version = Date.now().toString(), versions.set(filename, version)), version;
+}
+function shouldSkip(specifier) {
+  if (Module.isBuiltin(specifier) || specifier.includes("/node_modules/"))
+    return true;
+  if (specifier.startsWith(".") || specifier.startsWith("file://")) {
+    let filePath = specifier.startsWith("file://") ? fileURLToPath(specifier) : specifier, filename = basename(filePath);
+    return !EXTENSIONS.some((ext) => filename.endsWith(ext));
+  }
+  return true;
+}
+function onUnload(id, path) {
+  let deleted = versions.delete(resolve$1(path));
+  rpc.success(id, deleted);
+}
+
+export { initialize, load, resolve };