appstage 0.2.5 → 0.2.7

package/dist/bin.js

@@ -25,8 +25,146 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/dateshape/dist/index.cjs
+// node_modules/args-json/dist/index.cjs
 var require_dist = __commonJS({
+  "node_modules/args-json/dist/index.cjs"(exports) {
+    Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    function isKey2(x) {
+      return x.startsWith("-") && x.length === 2 && x !== "--" || x.startsWith("--") && x.length > 2;
+    }
+    var Args2 = class {
+      _values;
+      constructor(values) {
+        this._values = values ?? process.argv.slice(2);
+      }
+      hasKey(x) {
+        return isKey2(x) && this._values.includes(x);
+      }
+      getValue(key, fallback) {
+        let args = this._values;
+        let keys = Array.isArray(key) ? key : [key];
+        for (let k of keys) {
+          let i = args.indexOf(k);
+          if (i !== -1 && args[i + 1] && !isKey2(args[i + 1])) return args[i + 1];
+        }
+        return fallback;
+      }
+      getValues(key, fallback) {
+        let args = this._values;
+        let keys = Array.isArray(key) ? key : [key];
+        let values = [];
+        for (let k of keys) {
+          let i = args.indexOf(k);
+          while (i !== -1 && args[i + 1] && !isKey2(args[i + 1])) values.push(args[++i]);
+        }
+        return values.length === 0 ? fallback : values;
+      }
+    };
+    function getValue(key, fallback) {
+      let args = new Args2();
+      if (fallback === void 0) return args.getValue(key);
+      return args.getValue(key, fallback);
+    }
+    function getValues(key, fallback) {
+      let args = new Args2();
+      if (fallback === void 0) return args.getValues(key);
+      return args.getValues(key, fallback);
+    }
+    function hasKey2(x) {
+      return new Args2().hasKey(x);
+    }
+    function split(x) {
+      let words = [], word = "";
+      let hasOpenSingleQuote = false;
+      let hasOpenDoubleQuote = false;
+      for (let i = 0; i < x.length; i++) {
+        let c = x[i];
+        if (/^\s/.test(c) && !hasOpenSingleQuote && !hasOpenDoubleQuote) {
+          if (word) words.push(word);
+          word = "";
+          continue;
+        }
+        if (c === "'" && x[i - 1] !== "\\") hasOpenSingleQuote = !hasOpenSingleQuote;
+        if (c === '"' && x[i - 1] !== "\\") hasOpenDoubleQuote = !hasOpenDoubleQuote;
+        word += c;
+      }
+      if (word) words.push(word);
+      return words;
+    }
+    function toCamelCase(x) {
+      let s = x.replace(/^[-_.\s~+]|[-_.\s~+]$/g, "");
+      if (!/[-_.\s~+]/.test(s)) return s.slice(0, 1).toLowerCase() + s.slice(1);
+      return s.toLowerCase().replace(/[-_.\s~+](\S)/g, (_, match) => match.toUpperCase());
+    }
+    function toKey(x) {
+      if (x === void 0 || !isKey2(x)) return;
+      if (x.startsWith("-") && x.length === 2) return toCamelCase(x.slice(1));
+      if (x.startsWith("--") && x.length > 2) return toCamelCase(x.slice(2));
+    }
+    function getDefaultInput() {
+      return typeof process === "undefined" ? [] : process.argv;
+    }
+    function parseArgs(input, map) {
+      let normalizedInput;
+      let normalizedMap;
+      if (input === void 0) normalizedInput = getDefaultInput();
+      else if (typeof input === "string") normalizedInput = split(input);
+      else if (Array.isArray(input)) normalizedInput = input.map((x) => String(x));
+      else if (input !== null && typeof input === "object") {
+        normalizedInput = getDefaultInput();
+        normalizedMap = input;
+      } else normalizedInput = [];
+      normalizedInput = normalizedInput.flatMap((item) => {
+        let normalizedItem = item.trim();
+        let k = normalizedItem.indexOf("=");
+        if (k === -1) return normalizedItem;
+        let key2 = normalizedItem.slice(0, k);
+        let value = normalizedItem.slice(k + 1);
+        if (!isKey2(key2)) return normalizedItem;
+        return [key2, value];
+      });
+      if (map) normalizedMap = map;
+      let key = "";
+      let parsedArgs = {};
+      for (let rawValue of normalizedInput) {
+        rawValue = rawValue.trim();
+        if (rawValue.startsWith('"') && rawValue.endsWith('"')) rawValue = rawValue.slice(1, -1);
+        else if (rawValue.startsWith("'") && rawValue.endsWith("'")) rawValue = rawValue.slice(1, -1);
+        let parsedKey = toKey(rawValue);
+        if (parsedKey !== void 0) {
+          let nextKey = normalizedMap?.[parsedKey] ?? parsedKey;
+          if (key && nextKey !== key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+          key = nextKey;
+          continue;
+        }
+        let parsedValue;
+        if (rawValue) try {
+          parsedValue = JSON.parse(rawValue);
+        } catch {
+          parsedValue = rawValue;
+        }
+        else parsedValue = true;
+        let prevValue = parsedArgs[key];
+        let value;
+        if (prevValue === void 0) value = key === "" ? [parsedValue] : parsedValue;
+        else if (Array.isArray(prevValue)) value = [...prevValue, parsedValue];
+        else value = [prevValue, parsedValue];
+        parsedArgs[key] = value;
+      }
+      if (key && parsedArgs[key] === void 0) parsedArgs[key] = true;
+      return parsedArgs;
+    }
+    exports.Args = Args2;
+    exports.getValue = getValue;
+    exports.getValues = getValues;
+    exports.hasKey = hasKey2;
+    exports.isKey = isKey2;
+    exports.parseArgs = parseArgs;
+  }
+});
+
+// node_modules/dateshape/dist/index.cjs
+var require_dist2 = __commonJS({
   "node_modules/dateshape/dist/index.cjs"(exports) {
     var SEC = 1e3;
     var MIN = 60 * SEC;
@@ -215,11 +353,15 @@ var require_dist = __commonJS({
   }
 });
 
+// src/scripts/bin.ts
+var import_args_json2 = __toESM(require_dist(), 1);
+
 // src/scripts/cli.ts
+var import_args_json = __toESM(require_dist(), 1);
 import { rm as rm2 } from "node:fs/promises";
 
 // src/scripts/build.ts
-var import_dateshape = __toESM(require_dist(), 1);
+var import_dateshape = __toESM(require_dist2(), 1);
 import { spawn } from "node:child_process";
 
 // src/scripts/utils/buildClient.ts
@@ -291,15 +433,19 @@ async function getEntryPoints(path) {
 }
 
 // src/scripts/utils/buildClient.ts
-async function buildClient({ publicAssetsDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints(["ui/index"]);
+async function buildClient({ clientDir, watch, watchClient }, plugins) {
+  let clientEntries = await getEntryPoints([
+    "ui/index",
+    "client/index",
+    "index"
+  ]);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
     bundle: true,
     splitting: true,
     format: "esm",
-    outdir: `${publicAssetsDir}/-`,
+    outdir: clientDir,
     outbase: "src/entries",
     minify: process.env.NODE_ENV !== "development",
     plugins
@@ -357,14 +503,14 @@ ${content}
 
 // src/scripts/utils/buildServer.ts
 async function buildServer(params, plugins) {
-  let { targetDir, watch, watchServer } = params;
+  let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: ["src/server/index.ts"],
     bundle: true,
     splitting: true,
-    outdir: `${targetDir}/server`,
+    outdir: `${serverDir}/server`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -382,7 +528,7 @@ async function buildServer(params, plugins) {
 
 // src/scripts/utils/buildServerCSS.ts
 import esbuild3 from "esbuild";
-async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
+async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
   let serverEntries = await getEntryPoints(["server", "server/index"]);
   let buildOptions = {
     ...commonBuildOptions,
@@ -392,7 +538,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
     })),
     bundle: true,
     splitting: false,
-    outdir: `${targetDir}/server-css`,
+    outdir: `${serverDir}/server-css`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -410,7 +556,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
 
 // src/scripts/utils/createPostbuildPlugins.ts
 import { mkdir, readdir as readdir2, rename, rm } from "node:fs/promises";
-function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild) {
+function createPostbuildPlugins({ serverDir, clientDir }, onServerRebuild) {
   let serverPlugins = [
     {
       name: "skip-css",
@@ -432,19 +578,19 @@ function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild)
       name: "postbuild-server-css",
       setup(build2) {
         build2.onEnd(async () => {
-          let dir = `${targetDir}/server-css`;
+          let dir = `${serverDir}/server-css`;
           try {
             let files = (await readdir2(dir)).filter(
               (name) => name.endsWith(".css")
             );
             if (files.length === 0) return;
-            await mkdir(`${publicAssetsDir}/-`, { recursive: true });
+            await mkdir(clientDir, { recursive: true });
             await Promise.all(
               files.map(async (name) => {
-                let dir2 = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+                let dir2 = `${clientDir}/${name.slice(0, -4)}`;
                 await mkdir(dir2, { recursive: true });
                 await rename(
-                  `${targetDir}/server-css/${name}`,
+                  `${serverDir}/server-css/${name}`,
                   `${dir2}/index.css`
                 );
               })
@@ -480,7 +626,7 @@ async function build(params) {
       inited = true;
     }
     if (params.start)
-      serverProcess = spawn("node", [`${params.targetDir}/server/index.js`], {
+      serverProcess = spawn("node", [`${params.serverDir}/server/index.js`], {
         stdio: "inherit"
       });
   }
@@ -496,38 +642,32 @@ async function build(params) {
 }
 
 // src/scripts/cli.ts
-var defaultTargetDir = "dist";
-async function clean({ targetDir, publicAssetsDir }) {
-  let dirs = [
-    `${targetDir}/server`,
-    `${targetDir}/server-css`,
-    `${publicAssetsDir}/-`
-  ];
+async function clean({ serverDir, clientDir }) {
+  let dirs = [`${serverDir}/server`, `${serverDir}/server-css`, clientDir];
   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;
+async function cli(input = []) {
+  let args = new import_args_json.Args(input);
+  let clientDir = args.getValue("--client-dir");
+  let serverDir = args.getValue("--server-dir", "dist");
+  if (!clientDir) throw new Error("Public assets directory is undefined");
   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")
+    serverDir,
+    clientDir,
+    silent: args.hasKey("--silent"),
+    watch: args.hasKey("--watch"),
+    watchServer: args.hasKey("--watch-server"),
+    watchClient: args.hasKey("--watch-client"),
+    start: args.hasKey("--start")
   };
-  if (args.includes("--no-auto-entries")) params.entriesPath = null;
-  if (args.includes("--clean-only")) {
+  if (args.hasKey("--no-auto-entries")) params.entriesPath = null;
+  if (args.hasKey("--clean-only")) {
     await clean(params);
     return;
   }
-  if (args.includes("--clean")) await clean(params);
+  if (args.hasKey("--clean")) await clean(params);
   await build(params);
 }
 
@@ -545,15 +685,16 @@ async function run() {
   }
   if (scriptName === "build") return await cli(args);
   let nodeEnv = nodeEnvMap[scriptName];
-  let host = args.shift();
   if (nodeEnv !== void 0) process.env.NODE_ENV = nodeEnv;
-  if (host) {
-    let [hostname, port] = host.split(":");
+  if (args.length !== 0 && !(0, import_args_json2.isKey)(args[0])) {
+    let [hostname, port] = args[0].split(":");
     if (hostname) process.env.APP_HOST = hostname;
     if (port) process.env.APP_PORT = port;
+    args.shift();
   }
+  if (!(0, import_args_json2.hasKey)("--client-dir")) args.push("--client-dir", "src/public/-");
   await cli(
-    nodeEnv === "development" ? ["src/public", "--clean", "--start", "--watch", ...args] : ["src/public", "--clean", "--start", "--silent", ...args]
+    nodeEnv === "development" ? ["--clean", "--start", "--watch", ...args] : ["--clean", "--start", "--silent", ...args]
   );
 }
 await run();

package/dist/index.cjs

@@ -29,6 +29,7 @@ let node_http = require("node:http");
 let node_child_process = require("node:child_process");
 let esbuild = require("esbuild");
 esbuild = __toESM(esbuild);
+let args_json = require("args-json");
 let node_events = require("node:events");
 node_events = __toESM(node_events);
 let express = require("express");
@@ -363,20 +364,21 @@ async function getEntryPoints(path) {
 }
 
 /**
-* Builds the client-side code from the 'src/entries/<entry_name>/ui'
-* directories. The directories should preferrably be called 'ui' rather
-* than client since their contents can also be used with the server-side
-* rendering.
+* Builds the client-side code.
 */
-async function buildClient({ publicAssetsDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints(["ui/index"]);
+async function buildClient({ clientDir, watch, watchClient }, plugins) {
+  let clientEntries = await getEntryPoints([
+    "ui/index",
+    "client/index",
+    "index"
+  ]);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
     bundle: true,
     splitting: true,
     format: "esm",
-    outdir: `${publicAssetsDir}/-`,
+    outdir: clientDir,
     outbase: "src/entries",
     minify: process.env.NODE_ENV !== "development",
     plugins
@@ -416,14 +418,14 @@ ${content}
 }
 
 async function buildServer(params, plugins) {
-  let { targetDir, watch, watchServer } = params;
+  let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: ["src/server/index.ts"],
     bundle: true,
     splitting: true,
-    outdir: `${targetDir}/server`,
+    outdir: `${serverDir}/server`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -439,7 +441,7 @@ async function buildServer(params, plugins) {
   await esbuild.default.build(buildOptions);
 }
 
-async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
+async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
   let serverEntries = await getEntryPoints(["server", "server/index"]);
   let buildOptions = {
     ...commonBuildOptions,
@@ -449,7 +451,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
     })),
     bundle: true,
     splitting: false,
-    outdir: `${targetDir}/server-css`,
+    outdir: `${serverDir}/server-css`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -465,7 +467,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
   await esbuild.default.build(buildOptions);
 }
 
-function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild) {
+function createPostbuildPlugins({ serverDir, clientDir }, onServerRebuild) {
   return {
     serverPlugins: [{
       name: "skip-css",
@@ -485,15 +487,15 @@ function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild)
       name: "postbuild-server-css",
       setup(build) {
         build.onEnd(async () => {
-          let dir = `${targetDir}/server-css`;
+          let dir = `${serverDir}/server-css`;
           try {
             let files = (await (0, node_fs_promises.readdir)(dir)).filter((name) => name.endsWith(".css"));
             if (files.length === 0) return;
-            await (0, node_fs_promises.mkdir)(`${publicAssetsDir}/-`, { recursive: true });
+            await (0, node_fs_promises.mkdir)(clientDir, { recursive: true });
             await Promise.all(files.map(async (name) => {
-              let dir = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+              let dir = `${clientDir}/${name.slice(0, -4)}`;
               await (0, node_fs_promises.mkdir)(dir, { recursive: true });
-              await (0, node_fs_promises.rename)(`${targetDir}/server-css/${name}`, `${dir}/index.css`);
+              await (0, node_fs_promises.rename)(`${serverDir}/server-css/${name}`, `${dir}/index.css`);
             }));
             await (0, node_fs_promises.rm)(dir, {
               recursive: true,
@@ -521,7 +523,7 @@ async function build(params) {
       log(`Build completed +${(0, dateshape.formatDuration)(Date.now() - startTime)}`);
       inited = true;
     }
-    if (params.start) serverProcess = (0, node_child_process.spawn)("node", [`${params.targetDir}/server/index.js`], { stdio: "inherit" });
+    if (params.start) serverProcess = (0, node_child_process.spawn)("node", [`${params.serverDir}/server/index.js`], { stdio: "inherit" });
   }
   let { serverPlugins, serverCSSPlugins } = createPostbuildPlugins(params, handleServerRebuild);
   await Promise.all([
@@ -531,38 +533,37 @@ async function build(params) {
   ]);
 }
 
-const defaultTargetDir = "dist";
-async function clean({ targetDir, publicAssetsDir }) {
+async function clean({ serverDir, clientDir }) {
   let dirs = [
-    `${targetDir}/server`,
-    `${targetDir}/server-css`,
-    `${publicAssetsDir}/-`
+    `${serverDir}/server`,
+    `${serverDir}/server-css`,
+    clientDir
   ];
   return Promise.all(dirs.map((dir) => (0, node_fs_promises.rm)(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;
+async function cli(input = []) {
+  let args = new args_json.Args(input);
+  let clientDir = args.getValue("--client-dir");
+  let serverDir = args.getValue("--server-dir", "dist");
+  if (!clientDir) throw new Error("Public assets directory is undefined");
   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")
+    serverDir,
+    clientDir,
+    silent: args.hasKey("--silent"),
+    watch: args.hasKey("--watch"),
+    watchServer: args.hasKey("--watch-server"),
+    watchClient: args.hasKey("--watch-client"),
+    start: args.hasKey("--start")
   };
-  if (args.includes("--no-auto-entries")) params.entriesPath = null;
-  if (args.includes("--clean-only")) {
+  if (args.hasKey("--no-auto-entries")) params.entriesPath = null;
+  if (args.hasKey("--clean-only")) {
     await clean(params);
     return;
   }
-  if (args.includes("--clean")) await clean(params);
+  if (args.hasKey("--clean")) await clean(params);
   await build(params);
 }
 

package/dist/index.d.ts

@@ -131,8 +131,8 @@ declare const lang$1: Middleware<LangParams | void>;
 declare const requestEvents: Middleware;
 
 type BuildParams = {
-  targetDir: string;
-  publicAssetsDir: string;
+  serverDir: string;
+  clientDir: string;
   silent?: boolean;
   watch?: boolean;
   watchClient?: boolean;
@@ -151,7 +151,7 @@ type BuildParams = {
 
 declare function build(params: BuildParams): Promise<void>;
 
-declare function cli(args?: string[]): Promise<void>;
+declare function cli(input?: string[]): Promise<void>;
 
 type LogLevel = "error" | "debug" | "info" | "warn";
 

package/dist/index.mjs

@@ -5,6 +5,7 @@ import { randomBytes } from "node:crypto";
 import { STATUS_CODES } from "node:http";
 import { spawn } from "node:child_process";
 import esbuild from "esbuild";
+import { Args } from "args-json";
 import EventEmitter from "node:events";
 import express from "express";
 
@@ -337,20 +338,21 @@ async function getEntryPoints(path) {
 }
 
 /**
-* Builds the client-side code from the 'src/entries/<entry_name>/ui'
-* directories. The directories should preferrably be called 'ui' rather
-* than client since their contents can also be used with the server-side
-* rendering.
+* Builds the client-side code.
 */
-async function buildClient({ publicAssetsDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints(["ui/index"]);
+async function buildClient({ clientDir, watch, watchClient }, plugins) {
+  let clientEntries = await getEntryPoints([
+    "ui/index",
+    "client/index",
+    "index"
+  ]);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
     bundle: true,
     splitting: true,
     format: "esm",
-    outdir: `${publicAssetsDir}/-`,
+    outdir: clientDir,
     outbase: "src/entries",
     minify: process.env.NODE_ENV !== "development",
     plugins
@@ -390,14 +392,14 @@ ${content}
 }
 
 async function buildServer(params, plugins) {
-  let { targetDir, watch, watchServer } = params;
+  let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: ["src/server/index.ts"],
     bundle: true,
     splitting: true,
-    outdir: `${targetDir}/server`,
+    outdir: `${serverDir}/server`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -413,7 +415,7 @@ async function buildServer(params, plugins) {
   await esbuild.build(buildOptions);
 }
 
-async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
+async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
   let serverEntries = await getEntryPoints(["server", "server/index"]);
   let buildOptions = {
     ...commonBuildOptions,
@@ -423,7 +425,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
     })),
     bundle: true,
     splitting: false,
-    outdir: `${targetDir}/server-css`,
+    outdir: `${serverDir}/server-css`,
     platform: "node",
     format: "esm",
     packages: "external",
@@ -439,7 +441,7 @@ async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
   await esbuild.build(buildOptions);
 }
 
-function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild) {
+function createPostbuildPlugins({ serverDir, clientDir }, onServerRebuild) {
   return {
     serverPlugins: [{
       name: "skip-css",
@@ -459,15 +461,15 @@ function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild)
       name: "postbuild-server-css",
       setup(build) {
         build.onEnd(async () => {
-          let dir = `${targetDir}/server-css`;
+          let dir = `${serverDir}/server-css`;
           try {
             let files = (await readdir(dir)).filter((name) => name.endsWith(".css"));
             if (files.length === 0) return;
-            await mkdir(`${publicAssetsDir}/-`, { recursive: true });
+            await mkdir(clientDir, { recursive: true });
             await Promise.all(files.map(async (name) => {
-              let dir = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+              let dir = `${clientDir}/${name.slice(0, -4)}`;
               await mkdir(dir, { recursive: true });
-              await rename(`${targetDir}/server-css/${name}`, `${dir}/index.css`);
+              await rename(`${serverDir}/server-css/${name}`, `${dir}/index.css`);
             }));
             await rm(dir, {
               recursive: true,
@@ -495,7 +497,7 @@ async function build(params) {
       log(`Build completed +${formatDuration(Date.now() - startTime)}`);
       inited = true;
     }
-    if (params.start) serverProcess = spawn("node", [`${params.targetDir}/server/index.js`], { stdio: "inherit" });
+    if (params.start) serverProcess = spawn("node", [`${params.serverDir}/server/index.js`], { stdio: "inherit" });
   }
   let { serverPlugins, serverCSSPlugins } = createPostbuildPlugins(params, handleServerRebuild);
   await Promise.all([
@@ -505,38 +507,37 @@ async function build(params) {
   ]);
 }
 
-const defaultTargetDir = "dist";
-async function clean({ targetDir, publicAssetsDir }) {
+async function clean({ serverDir, clientDir }) {
   let dirs = [
-    `${targetDir}/server`,
-    `${targetDir}/server-css`,
-    `${publicAssetsDir}/-`
+    `${serverDir}/server`,
+    `${serverDir}/server-css`,
+    clientDir
   ];
   return Promise.all(dirs.map((dir) => rm(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;
+async function cli(input = []) {
+  let args = new Args(input);
+  let clientDir = args.getValue("--client-dir");
+  let serverDir = args.getValue("--server-dir", "dist");
+  if (!clientDir) throw new Error("Public assets directory is undefined");
   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")
+    serverDir,
+    clientDir,
+    silent: args.hasKey("--silent"),
+    watch: args.hasKey("--watch"),
+    watchServer: args.hasKey("--watch-server"),
+    watchClient: args.hasKey("--watch-client"),
+    start: args.hasKey("--start")
   };
-  if (args.includes("--no-auto-entries")) params.entriesPath = null;
-  if (args.includes("--clean-only")) {
+  if (args.hasKey("--no-auto-entries")) params.entriesPath = null;
+  if (args.hasKey("--clean-only")) {
     await clean(params);
     return;
   }
-  if (args.includes("--clean")) await clean(params);
+  if (args.hasKey("--clean")) await clean(params);
   await build(params);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appstage",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -29,7 +29,8 @@
     "@types/node": "^25.4.0"
   },
   "dependencies": {
+    "args-json": "^1.3.3",
     "dateshape": "^1.1.2",
-    "esbuild": "^0.27.3"
+    "esbuild": "^0.27.4"
   }
 }

package/src/scripts/bin.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { hasKey, isKey } from "args-json";
 import { cli } from "./cli.ts";
 
 const availableScriptNames = new Set(["build", "dev", "prod"]);
@@ -19,21 +20,24 @@ async function run() {
   if (scriptName === "build") return await cli(args);
 
   let nodeEnv = nodeEnvMap[scriptName];
-  let host = args.shift();
 
   if (nodeEnv !== undefined) process.env.NODE_ENV = nodeEnv;
 
-  if (host) {
-    let [hostname, port] = host.split(":");
+  if (args.length !== 0 && !isKey(args[0])) {
+    let [hostname, port] = args[0].split(":");
 
     if (hostname) process.env.APP_HOST = hostname;
     if (port) process.env.APP_PORT = port;
+
+    args.shift();
   }
 
+  if (!hasKey("--client-dir")) args.push("--client-dir", "src/public/-");
+
   await cli(
     nodeEnv === "development"
-      ? ["src/public", "--clean", "--start", "--watch", ...args]
-      : ["src/public", "--clean", "--start", "--silent", ...args],
+      ? ["--clean", "--start", "--watch", ...args]
+      : ["--clean", "--start", "--silent", ...args],
   );
 }
 

package/src/scripts/build.ts

@@ -27,7 +27,7 @@ export async function build(params: BuildParams) {
     }
 
     if (params.start)
-      serverProcess = spawn("node", [`${params.targetDir}/server/index.js`], {
+      serverProcess = spawn("node", [`${params.serverDir}/server/index.js`], {
         stdio: "inherit",
       });
   }

package/src/scripts/cli.ts

@@ -1,48 +1,42 @@
 import { rm } from "node:fs/promises";
+import { Args } from "args-json";
 import { build } from "./build.ts";
 import type { BuildParams } from "./types/BuildParams.ts";
 
-const defaultTargetDir = "dist";
-
-async function clean({ targetDir, publicAssetsDir }: BuildParams) {
-  let dirs = [
-    `${targetDir}/server`,
-    `${targetDir}/server-css`,
-    `${publicAssetsDir}/-`,
-  ];
+async function clean({ serverDir, clientDir }: BuildParams) {
+  let dirs = [`${serverDir}/server`, `${serverDir}/server-css`, clientDir];
 
   return Promise.all(
     dirs.map((dir) => rm(dir, { recursive: true, force: true })),
   );
 }
 
-export async function cli(args: string[] = []) {
-  let publicAssetsDir = args[0];
-  let targetDir = args[1];
+export async function cli(input: string[] = []) {
+  let args = new Args(input);
 
-  if (!publicAssetsDir || publicAssetsDir.startsWith("--"))
-    throw new Error("Public assets directory is undefined");
+  let clientDir = args.getValue("--client-dir");
+  let serverDir = args.getValue("--server-dir", "dist");
 
-  if (!targetDir || targetDir.startsWith("--")) targetDir = defaultTargetDir;
+  if (!clientDir) throw new Error("Public assets directory is undefined");
 
   let params: BuildParams = {
-    targetDir,
-    publicAssetsDir,
-    silent: args.includes("--silent"),
-    watch: args.includes("--watch"),
-    watchServer: args.includes("--watch-server"),
-    watchClient: args.includes("--watch-client"),
-    start: args.includes("--start"),
+    serverDir,
+    clientDir,
+    silent: args.hasKey("--silent"),
+    watch: args.hasKey("--watch"),
+    watchServer: args.hasKey("--watch-server"),
+    watchClient: args.hasKey("--watch-client"),
+    start: args.hasKey("--start"),
   };
 
-  if (args.includes("--no-auto-entries")) params.entriesPath = null;
+  if (args.hasKey("--no-auto-entries")) params.entriesPath = null;
 
-  if (args.includes("--clean-only")) {
+  if (args.hasKey("--clean-only")) {
     await clean(params);
     return;
   }
 
-  if (args.includes("--clean")) await clean(params);
+  if (args.hasKey("--clean")) await clean(params);
 
   await build(params);
 }

package/src/scripts/types/BuildParams.ts

@@ -1,6 +1,6 @@
 export type BuildParams = {
-  targetDir: string;
-  publicAssetsDir: string;
+  serverDir: string;
+  clientDir: string;
   silent?: boolean;
   watch?: boolean;
   watchClient?: boolean;

package/src/scripts/utils/buildClient.ts

@@ -4,16 +4,17 @@ import type { BuildParams } from "../types/BuildParams.ts";
 import { getEntryPoints } from "./getEntryPoints.ts";
 
 /**
- * Builds the client-side code from the 'src/entries/<entry_name>/ui'
- * directories. The directories should preferrably be called 'ui' rather
- * than client since their contents can also be used with the server-side
- * rendering.
+ * Builds the client-side code.
  */
 export async function buildClient(
-  { publicAssetsDir, watch, watchClient }: BuildParams,
+  { clientDir, watch, watchClient }: BuildParams,
   plugins?: Plugin[],
 ) {
-  let clientEntries = await getEntryPoints(["ui/index"]);
+  let clientEntries = await getEntryPoints([
+    "ui/index",
+    "client/index",
+    "index",
+  ]);
 
   let buildOptions: BuildOptions = {
     ...commonBuildOptions,
@@ -21,7 +22,7 @@ export async function buildClient(
     bundle: true,
     splitting: true,
     format: "esm",
-    outdir: `${publicAssetsDir}/-`,
+    outdir: clientDir,
     outbase: "src/entries",
     minify: process.env.NODE_ENV !== "development",
     plugins,

package/src/scripts/utils/buildServer.ts

@@ -4,7 +4,7 @@ import type { BuildParams } from "../types/BuildParams.ts";
 import { populateEntries } from "./populateEntries.ts";
 
 export async function buildServer(params: BuildParams, plugins?: Plugin[]) {
-  let { targetDir, watch, watchServer } = params;
+  let { serverDir, watch, watchServer } = params;
 
   await populateEntries(params);
 
@@ -13,7 +13,7 @@ export async function buildServer(params: BuildParams, plugins?: Plugin[]) {
     entryPoints: ["src/server/index.ts"],
     bundle: true,
     splitting: true,
-    outdir: `${targetDir}/server`,
+    outdir: `${serverDir}/server`,
     platform: "node",
     format: "esm",
     packages: "external",

package/src/scripts/utils/buildServerCSS.ts

@@ -4,7 +4,7 @@ import type { BuildParams } from "../types/BuildParams.ts";
 import { getEntryPoints } from "./getEntryPoints.ts";
 
 export async function buildServerCSS(
-  { targetDir, watch, watchServer }: BuildParams,
+  { serverDir, watch, watchServer }: BuildParams,
   plugins?: Plugin[],
 ) {
   let serverEntries = await getEntryPoints(["server", "server/index"]);
@@ -17,7 +17,7 @@ export async function buildServerCSS(
     })),
     bundle: true,
     splitting: false,
-    outdir: `${targetDir}/server-css`,
+    outdir: `${serverDir}/server-css`,
     platform: "node",
     format: "esm",
     packages: "external",

package/src/scripts/utils/createPostbuildPlugins.ts

@@ -3,7 +3,7 @@ import type { Plugin } from "esbuild";
 import type { BuildParams } from "../types/BuildParams.ts";
 
 export function createPostbuildPlugins(
-  { targetDir, publicAssetsDir }: BuildParams,
+  { serverDir, clientDir }: BuildParams,
   onServerRebuild: () => void,
 ) {
   let serverPlugins: Plugin[] = [
@@ -29,7 +29,7 @@ export function createPostbuildPlugins(
       name: "postbuild-server-css",
       setup(build) {
         build.onEnd(async () => {
-          let dir = `${targetDir}/server-css`;
+          let dir = `${serverDir}/server-css`;
 
           try {
             let files = (await readdir(dir)).filter((name) =>
@@ -38,15 +38,15 @@ export function createPostbuildPlugins(
 
             if (files.length === 0) return;
 
-            await mkdir(`${publicAssetsDir}/-`, { recursive: true });
+            await mkdir(clientDir, { recursive: true });
 
             await Promise.all(
               files.map(async (name) => {
-                let dir = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+                let dir = `${clientDir}/${name.slice(0, -4)}`;
 
                 await mkdir(dir, { recursive: true });
                 await rename(
-                  `${targetDir}/server-css/${name}`,
+                  `${serverDir}/server-css/${name}`,
                   `${dir}/index.css`,
                 );
               }),