appstage 0.2.1

package/dist/bin/startDev.js

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/dateshape/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/dateshape/dist/index.cjs"(exports) {
+    var SEC = 1e3;
+    var MIN = 60 * SEC;
+    var HOUR = 60 * MIN;
+    var DAY = 24 * HOUR;
+    var INVALID_DATE_STRING = (/* @__PURE__ */ new Date("-")).toString();
+    function escapeRegExp(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function fill(template, data, transformMap) {
+      let s = template;
+      for (let [key, value] of Object.entries(data)) {
+        let transform = transformMap?.[key];
+        s = s.replace(new RegExp(escapeRegExp(`{${key}}`), "g"), String(transform ? transform(data) : value));
+      }
+      if (transformMap) for (let [key, transform] of Object.entries(transformMap)) {
+        if (key in data) continue;
+        s = s.replace(new RegExp(escapeRegExp(`{${key}}`), "g"), String(transform(data)));
+      }
+      return s;
+    }
+    function getTimezone(dateString) {
+      if (!dateString) return;
+      if (/(^|T|\s)\d\d:\d\d:\d\d(\.\d{3})?Z(\s|$)/.test(dateString)) return "Z";
+      return dateString.match(/[+-]\d\d:?\d\d\b/)?.[0];
+    }
+    function getTimezoneOffset(timezone) {
+      if (timezone === "Z") return 0;
+      let [, sign2, h, m] = timezone?.match(/^([+-])?(\d\d):?(\d\d)$/) ?? [];
+      if (!sign2 || !h || !m) return;
+      return (sign2 === "-" ? 1 : -1) * (parseInt(h, 10) * 60 + parseInt(m, 10));
+    }
+    function toTimestamp(x) {
+      return (x instanceof Date ? x : new Date(x)).getTime();
+    }
+    function isInvalidDate(date) {
+      return Number.isNaN(toTimestamp(date));
+    }
+    function pad(x, length, padding = "0") {
+      return String(x).padStart(length, padding);
+    }
+    var { abs: abs$1, floor: floor$1, sign: sign$1 } = Math;
+    function getDateComponents(date, targetTimezone) {
+      if (isInvalidDate(date)) return;
+      let d = date instanceof Date ? date : new Date(date);
+      let tzOffset = d.getTimezoneOffset();
+      let targetTzOffset = getTimezoneOffset(targetTimezone);
+      if (typeof date === "string") {
+        let originalTzOffset = getTimezoneOffset(getTimezone(date));
+        if (originalTzOffset !== void 0) {
+          if (targetTzOffset === void 0) targetTzOffset = originalTzOffset;
+          d.setTime(d.getTime() + (tzOffset - targetTzOffset) * MIN);
+        }
+      }
+      if (targetTzOffset !== void 0) tzOffset = targetTzOffset;
+      let year = d.getFullYear();
+      let month = d.getMonth();
+      let day = d.getDate();
+      let weekDay = d.getDay();
+      let Y = String(year);
+      let M = String(month + 1);
+      let D = String(day);
+      let absYear = abs$1(year);
+      let yearSign = sign$1(year) === -1 ? "-" : "";
+      let YY = `${yearSign}${pad(absYear, 2)}`;
+      let MM = pad(M, 2);
+      let DD = pad(D, 2);
+      let YYYY = `${yearSign}${pad(absYear, 4)}`;
+      let yy = pad(absYear % 100, 2);
+      let hours = d.getHours();
+      let minutes = d.getMinutes();
+      let seconds = d.getSeconds();
+      let milliseconds = d.getMilliseconds();
+      let H = String(hours);
+      let m = String(minutes);
+      let s = String(seconds);
+      let HH = pad(H, 2);
+      let mm = pad(m, 2);
+      let ss = pad(s, 2);
+      let ms = pad(milliseconds, 3);
+      let YE = String(year < 1 ? abs$1(year - 1) : year);
+      let E = year < 1 ? -1 : 1;
+      let CE = year < 1 ? -1 : 1;
+      let hours12 = hours % 12 || 12;
+      let h = String(hours12);
+      let hh = pad(h, 2);
+      let a = hours < 12 ? "AM" : "PM";
+      let tzSign = -sign$1(tzOffset);
+      let absTzOffset = abs$1(tzOffset);
+      let tzHours = floor$1(absTzOffset / 60);
+      let tzMinutes = absTzOffset - tzHours * 60;
+      let tz = `${tzSign === -1 ? "-" : "+"}${pad(tzHours, 2)}:${pad(tzMinutes, 2)}`;
+      let isoDate = `${YYYY}-${MM}-${DD}`;
+      let isoTime = `${HH}:${mm}:${ss}`;
+      let isoTimeMs = `${isoTime}.${ms}`;
+      let iso = `${isoDate}T${isoTimeMs}${tz}`;
+      return {
+        input: date,
+        date: d,
+        timestamp: d.getTime(),
+        year,
+        month,
+        day,
+        weekDay,
+        Y,
+        M,
+        D,
+        YY,
+        YYYY,
+        yy,
+        MM,
+        DD,
+        YE,
+        E,
+        CE,
+        hours,
+        minutes,
+        seconds,
+        milliseconds,
+        hours12,
+        H,
+        m,
+        s,
+        ms,
+        h,
+        a,
+        tz,
+        HH,
+        mm,
+        ss,
+        hh,
+        isoDate,
+        isoTime,
+        isoTimeMs,
+        iso,
+        timezoneOffset: tzOffset
+      };
+    }
+    function formatDate(date, template = "{iso}", transform, targetTimezone) {
+      if (isInvalidDate(date)) return INVALID_DATE_STRING;
+      if (typeof template === "object") {
+        let options = template;
+        transform = options.transform;
+        targetTimezone = options.targetTimezone;
+        template = options.template;
+      } else if (typeof transform === "string") {
+        targetTimezone = transform;
+        transform = void 0;
+      }
+      let dateComponents = getDateComponents(date, targetTimezone);
+      if (!dateComponents) return INVALID_DATE_STRING;
+      return fill(typeof template === "function" ? template(dateComponents) : template, dateComponents, transform);
+    }
+    var { abs, floor, sign } = Math;
+    function formatDuration2(duration) {
+      let durationSign = sign(duration);
+      let absDuration = abs(duration);
+      let d = floor(absDuration / DAY);
+      let h = floor((absDuration - d * DAY) / HOUR);
+      let m = floor((absDuration - d * DAY - h * HOUR) / MIN);
+      let s = floor((absDuration - d * DAY - h * HOUR - m * MIN) / SEC);
+      let ms = absDuration - d * DAY - h * HOUR - m * MIN - s * SEC;
+      let value = "";
+      value += d === 0 ? "" : `${d}d`;
+      value += value ? `${pad(h, 2)}h` : h === 0 ? "" : `${h}h`;
+      value += value ? `${pad(m, 2)}'` : m === 0 ? "" : `${m}'`;
+      value += `${value ? pad(s, 2) : s}.${pad(ms, 3)}"`;
+      return `${durationSign === -1 ? "-" : ""}${value}`;
+    }
+    function toLocalISOString(date) {
+      return formatDate(date, "{iso}");
+    }
+    exports.DAY = DAY;
+    exports.HOUR = HOUR;
+    exports.INVALID_DATE_STRING = INVALID_DATE_STRING;
+    exports.MIN = MIN;
+    exports.SEC = SEC;
+    exports.formatDate = formatDate;
+    exports.formatDuration = formatDuration2;
+    exports.getDateComponents = getDateComponents;
+    exports.getTimezone = getTimezone;
+    exports.getTimezoneOffset = getTimezoneOffset;
+    exports.isInvalidDate = isInvalidDate;
+    exports.toLocalISOString = toLocalISOString;
+    exports.toTimestamp = toTimestamp;
+  }
+});
+
+// src/scripts/cli.ts
+import { rm as rm2 } from "node:fs/promises";
+
+// src/scripts/build.ts
+var import_dateshape = __toESM(require_dist(), 1);
+import { spawn } from "node:child_process";
+
+// src/scripts/utils/buildClient.ts
+import esbuild from "esbuild";
+
+// src/scripts/const/commonBuildOptions.ts
+var commonBuildOptions = {
+  format: "cjs",
+  jsx: "automatic",
+  jsxDev: process.env.NODE_ENV === "development",
+  loader: {
+    ".png": "dataurl",
+    ".svg": "dataurl",
+    ".html": "text",
+    ".txt": "text"
+  }
+};
+
+// src/scripts/utils/getEntries.ts
+import { lstat, readdir } from "node:fs/promises";
+import { join } from "node:path";
+async function getEntries() {
+  let cwd = process.cwd();
+  try {
+    let list = await readdir(join(cwd, "src/entries"));
+    let dirs = await Promise.all(
+      list.map(async (name) => {
+        let itemStat = await lstat(join(cwd, "src/entries", name));
+        return itemStat.isDirectory() ? name : void 0;
+      })
+    );
+    return dirs.filter((dir) => dir !== void 0);
+  } catch {
+    return [];
+  }
+}
+
+// src/scripts/utils/getFirstAvailable.ts
+import { access } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/scripts/const/entryExtensions.ts
+var entryExtensions = ["js", "jsx", "ts", "tsx"];
+
+// src/scripts/utils/getFirstAvailable.ts
+async function getFirstAvailable(dirPath, path) {
+  let paths = Array.isArray(path) ? path : [path];
+  for (let filePath of paths) {
+    for (let ext of entryExtensions) {
+      let path2 = join2(process.cwd(), dirPath, `${filePath}.${ext}`);
+      try {
+        await access(path2);
+        return path2;
+      } catch {
+      }
+    }
+  }
+}
+
+// src/scripts/utils/getEntryPoints.ts
+async function getEntryPoints(path) {
+  let entries = await getEntries();
+  return (await Promise.all(
+    entries.map(async (name) => {
+      let resolvedPath = await getFirstAvailable(`src/entries/${name}`, path);
+      return resolvedPath === void 0 ? void 0 : { name, path: resolvedPath };
+    })
+  )).filter((item) => item !== void 0);
+}
+
+// src/scripts/utils/buildClient.ts
+async function buildClient({ publicAssetsDir, watch, watchClient }, plugins) {
+  let clientEntries = await getEntryPoints(["ui/index"]);
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: clientEntries.map(({ path }) => path),
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    outdir: `${publicAssetsDir}/-`,
+    outbase: "src/entries",
+    minify: process.env.NODE_ENV !== "development",
+    plugins
+  };
+  if (watch || watchClient) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild.build(buildOptions);
+}
+
+// src/scripts/utils/buildServer.ts
+import esbuild2 from "esbuild";
+
+// src/scripts/utils/populateEntries.ts
+import { writeFile } from "node:fs/promises";
+
+// src/scripts/utils/toImportPath.ts
+import { join as join3, posix, relative, sep } from "node:path";
+function toImportPath(relativePath, referencePath = ".") {
+  let cwd = process.cwd();
+  let importPath = posix.join(
+    ...relative(join3(cwd, referencePath), relativePath).split(sep)
+  );
+  if (importPath && !/^\.+\//.test(importPath)) importPath = `./${importPath}`;
+  return importPath;
+}
+
+// src/scripts/utils/populateEntries.ts
+async function populateEntries() {
+  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let content = "";
+  if (serverEntries.length === 0) content = "export const entries = [];";
+  else {
+    content = "export const entries = (\n  await Promise.all([";
+    for (let i = 0; i < serverEntries.length; i++) {
+      content += `
+    // ${serverEntries[i].name}
+    import("${toImportPath(serverEntries[i].path, "src/server")}"),`;
+    }
+    content += "\n  ])\n).map(({ server }) => server);";
+  }
+  await writeFile(
+    "src/server/entries.ts",
+    `// Populated automatically during the build phase by picking
+// all server exports from 'src/entries/<entry_name>/server(/index)?.(js|ts)'
+${content}
+`
+  );
+}
+
+// src/scripts/utils/buildServer.ts
+async function buildServer({ targetDir, watch, watchServer }, plugins) {
+  await populateEntries();
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: ["src/server/index.ts"],
+    bundle: true,
+    splitting: true,
+    outdir: `${targetDir}/server`,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins
+  };
+  if (watch || watchServer) {
+    let ctx = await esbuild2.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild2.build(buildOptions);
+}
+
+// src/scripts/utils/buildServerCSS.ts
+import esbuild3 from "esbuild";
+async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
+  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: serverEntries.map(({ name, path }) => ({
+      in: path,
+      out: name
+    })),
+    bundle: true,
+    splitting: false,
+    outdir: `${targetDir}/server-css`,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins
+  };
+  if (watch || watchServer) {
+    let ctx = await esbuild3.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild3.build(buildOptions);
+}
+
+// src/scripts/utils/createPostbuildPlugins.ts
+import { mkdir, readdir as readdir2, rename, rm } from "node:fs/promises";
+function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild) {
+  let serverPlugins = [
+    {
+      name: "skip-css",
+      setup(build2) {
+        build2.onLoad({ filter: /\.css$/ }, () => ({ contents: "" }));
+      }
+    },
+    {
+      name: "postbuild-server",
+      setup(build2) {
+        build2.onEnd(() => {
+          onServerRebuild();
+        });
+      }
+    }
+  ];
+  let serverCSSPlugins = [
+    {
+      name: "postbuild-server-css",
+      setup(build2) {
+        build2.onEnd(async () => {
+          let dir = `${targetDir}/server-css`;
+          try {
+            let files = (await readdir2(dir)).filter(
+              (name) => name.endsWith(".css")
+            );
+            if (files.length === 0) return;
+            await mkdir(`${publicAssetsDir}/-`, { recursive: true });
+            await Promise.all(
+              files.map(async (name) => {
+                let dir2 = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+                await mkdir(dir2, { recursive: true });
+                await rename(
+                  `${targetDir}/server-css/${name}`,
+                  `${dir2}/index.css`
+                );
+              })
+            );
+            await rm(dir, { recursive: true, force: true });
+          } catch {
+          }
+        });
+      }
+    }
+  ];
+  return {
+    serverPlugins,
+    serverCSSPlugins
+  };
+}
+
+// src/scripts/build.ts
+async function build(params) {
+  let startTime = Date.now();
+  let log = params.silent ? () => {
+  } : console.log;
+  log("Build started");
+  let serverProcess = null;
+  let inited = false;
+  function handleServerRebuild() {
+    if (serverProcess) {
+      serverProcess.kill();
+      serverProcess = null;
+    }
+    if (!inited) {
+      log(`Build completed +${(0, import_dateshape.formatDuration)(Date.now() - startTime)}`);
+      inited = true;
+    }
+    if (params.start)
+      serverProcess = spawn("node", [`${params.targetDir}/server/index.js`], {
+        stdio: "inherit"
+      });
+  }
+  let { serverPlugins, serverCSSPlugins } = createPostbuildPlugins(
+    params,
+    handleServerRebuild
+  );
+  await Promise.all([
+    buildServer(params, serverPlugins),
+    buildServerCSS(params, serverCSSPlugins),
+    buildClient(params)
+  ]);
+}
+
+// src/scripts/cli.ts
+var defaultTargetDir = "dist";
+async function clean({ targetDir, publicAssetsDir }) {
+  let dirs = [
+    `${targetDir}/server`,
+    `${targetDir}/server-css`,
+    `${publicAssetsDir}/-`
+  ];
+  return Promise.all(
+    dirs.map((dir) => rm2(dir, { recursive: true, force: true }))
+  );
+}
+async function cli(args = []) {
+  let publicAssetsDir = args[0];
+  let targetDir = args[1];
+  if (!publicAssetsDir || publicAssetsDir.startsWith("--"))
+    throw new Error("Public assets directory is undefined");
+  if (!targetDir || targetDir.startsWith("--")) targetDir = defaultTargetDir;
+  let params = {
+    targetDir,
+    publicAssetsDir,
+    silent: args.includes("--silent"),
+    watch: args.includes("--watch"),
+    watchServer: args.includes("--watch-server"),
+    watchClient: args.includes("--watch-client"),
+    start: args.includes("--start")
+  };
+  if (args.includes("--clean-only")) {
+    await clean(params);
+    return;
+  }
+  if (args.includes("--clean")) await clean(params);
+  await build(params);
+}
+
+// src/scripts/start.ts
+async function start(nodeEnv = "development", host) {
+  if (nodeEnv) process.env.NODE_ENV = nodeEnv;
+  if (host) {
+    let [hostname, port] = host.split(":");
+    if (hostname) process.env.APP_HOST = hostname;
+    if (port) process.env.APP_PORT = port;
+  }
+  await cli(
+    nodeEnv === "development" ? ["src/public", "--clean", "--start", "--watch"] : ["src/public", "--clean", "--start", "--silent"]
+  );
+}
+
+// src/scripts/bin/startDev.ts
+await start("development", process.argv[2]);