primate 0.32.7 → 0.33.0

package/lib/app.tsconfig.json

@@ -0,0 +1,55 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "baseUrl": "${configDir}",
+    "target": "esnext",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "skipLibCheck": true,
+    "customConditions": ["apekit"],
+    "erasableSyntaxOnly": true,
+    "exactOptionalPropertyTypes": true,
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "#route/*": ["routes/*"],
+      "#component/*": [
+        "components/*.tsx",
+        "components/*.jsx",
+        "components/*.vue",
+        "components/*.svelte",
+        "components/*.component.ts",
+        "components/*.ts",
+        "components/*.js",
+        "components/*"
+      ],
+      "#store/*":   ["stores/*",   "stores/*.ts",   "stores/*.js"],
+      "#locale/*":  ["locales/*",  "locales/*.ts",  "locales/*.js"],
+      "#module/*":  ["modules/*",  "modules/*.ts",  "modules/*.js"],
+      "#config/*":  ["config/*",   "config/*.ts",   "config/*.js"],
+      "#static/*":  ["static/*",   "static/*.ts",   "static/*.js"],
+      "#database/*": ["config/database/*.ts", "config/database/*.js"],
+      "#app": ["config/app.ts", "config/app.js"],
+      "#session": ["config/session.ts", "config/session.js"],
+      "#i18n": ["config/i18n.ts", "config/i18n.js"],
+      "#database": [
+        "config/database/index.ts",
+        "config/database/index.js",
+        "config/database/default.js",
+        "config/database/default.ts"
+      ]
+    }
+  },
+  "include": [
+    "${configDir}/config",
+    "${configDir}/routes",
+    "${configDir}/components",
+    "${configDir}/stores",
+    "${configDir}/modules",
+    "${configDir}/test",
+    "${configDir}/static",
+    "${configDir}/primate.config.js",
+    "${configDir}/primate.config.ts"
+  ],
+  "exclude": ["node_modules"]
+}

package/lib/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/{src → lib}/bin.js

@@ -2,3 +2,4 @@
 import args from "@rcompat/args";
 import init from "./init.js";
 await init(...args);
+//# sourceMappingURL=bin.js.map

package/lib/commands/build.d.ts

@@ -0,0 +1,4 @@
+import type Mode from "@primate/core/Mode";
+declare const _default: (flags: string[], mode?: Mode) => Promise<true | undefined>;
+export default _default;
+//# sourceMappingURL=build.d.ts.map

package/lib/commands/build.js

@@ -0,0 +1,9 @@
+import build from "@primate/core/build";
+const T_FLAG = "--target=";
+// build for production
+export default (flags, mode = "production") => {
+    const target = flags.find(f => f.startsWith(T_FLAG))?.slice(T_FLAG.length)
+        ?? "web";
+    return build(mode, target);
+};
+//# sourceMappingURL=build.js.map

package/lib/commands/dev.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=dev.d.ts.map

package/lib/commands/dev.js

@@ -0,0 +1,8 @@
+import build from "./build.js";
+import serve from "./serve.js";
+// build for development and serve
+export default async () => {
+    // will only serve is build is successful
+    await build(["--target=web"], "development") === true && serve();
+};
+//# sourceMappingURL=dev.js.map

package/lib/commands/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (name: string) => ((flags: string[], mode?: import("@primate/core/Mode").default) => Promise<true | undefined>) | (() => Promise<any>);
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/commands/index.js

@@ -0,0 +1,13 @@
+import { default as build } from "./build.js";
+import { default as dev } from "./dev.js";
+import { default as init } from "./init.js";
+import { default as serve } from "./serve.js";
+import { default as test } from "./test.js";
+export default (name) => ({
+    build,
+    dev,
+    init,
+    serve,
+    test,
+})[name] ?? dev;
+//# sourceMappingURL=index.js.map

package/lib/commands/init.d.ts

@@ -0,0 +1,2 @@
+export default function init(): Promise<symbol>;
+//# sourceMappingURL=init.d.ts.map

package/lib/commands/init.js

@@ -0,0 +1,348 @@
+import cancel from "@rcompat/cli/prompts/cancel";
+import intro from "@rcompat/cli/prompts/intro";
+import isCancel from "@rcompat/cli/prompts/is-cancel";
+import multiselect from "@rcompat/cli/prompts/multiselect";
+import outro from "@rcompat/cli/prompts/outro";
+import select from "@rcompat/cli/prompts/select";
+import text from "@rcompat/cli/prompts/text";
+import FileRef from "@rcompat/fs/FileRef";
+import dedent from "@rcompat/string/dedent";
+const FRONTEND_OPTIONS = [
+    { label: "Angular", value: "angular" },
+    { label: "Eta", value: "eta" },
+    { label: "HTML", value: "html" },
+    { label: "HTMX", value: "htmx" },
+    { label: "Handlebars", value: "handlebars" },
+    { label: "Markdown", value: "markdown" },
+    { label: "Marko", value: "marko" },
+    { label: "React", value: "react" },
+    { label: "Solid", value: "solid" },
+    { label: "Svelte", value: "svelte" },
+    { label: "Voby", value: "voby" },
+    { label: "Vue", value: "vue" },
+    { label: "Web Components", value: "webc" },
+];
+const BACKEND_OPTIONS = [
+    { label: "Go", value: "go" },
+    { label: "Python", value: "python" },
+    { label: "Ruby", value: "ruby" },
+    { label: "Grain", value: "grain" },
+];
+const DATABASE_OPTIONS = [
+    { label: "SQLite", value: "sqlite" },
+    { label: "PostgreSQL", value: "postgresql" },
+    { label: "MySQL", value: "mysql" },
+    { label: "MongoDB", value: "mongodb" },
+    { label: "SurrealDB", value: "surrealdb" },
+];
+// peer deps per frontend (npm names)
+const FRONTEND_PEER_DEPS = {
+    angular: [],
+    eta: [],
+    html: [],
+    htmx: [],
+    handlebars: [],
+    markdown: [],
+    marko: [],
+    react: ["react", "react-dom"],
+    solid: ["solid-js"],
+    svelte: ["svelte"],
+    voby: [],
+    vue: ["vue"],
+    "webc": [],
+};
+export default async function init() {
+    intro("Create a new Primate app");
+    let directory;
+    let target;
+    while (true) {
+        const ans = await text({ message: "Directory to create app?", initial: "." });
+        if (typeof ans === "symbol" || isCancel(ans))
+            return cancel("Aborted.");
+        target = new FileRef(ans);
+        if (await empty(target)) {
+            directory = ans;
+            break; // Valid directory found, exit loop
+        }
+        // Directory not empty, show error but continue loop
+        console.log("Directory not empty, choose another.");
+    }
+    // frontends — Enter = skip (none)
+    const fronts = await multiselect({
+        message: "Choose frontend (press Enter to skip)",
+        options: FRONTEND_OPTIONS,
+        initial: [], // indices
+    });
+    if (typeof fronts === "symbol" || isCancel(fronts))
+        return cancel("Aborted.");
+    // backends — Enter = skip (none)
+    const backs = await multiselect({
+        message: "Choose backend (press Enter to skip)",
+        options: BACKEND_OPTIONS,
+        initial: [], // indices
+    });
+    if (typeof backs === "symbol" || isCancel(backs))
+        return cancel("Aborted.");
+    // runtime (must choose one)
+    const runtime = await select({
+        message: "Choose runtime",
+        options: [
+            { label: "Node", value: "node" },
+            { label: "Deno", value: "deno" },
+            { label: "Bun", value: "bun" },
+        ],
+        initial: 0,
+    });
+    if (typeof runtime === "symbol" || isCancel(runtime))
+        return cancel("Aborted.");
+    // database — Enter = skip (none); if multiple chosen, take the first
+    const dbChoices = await multiselect({
+        message: "Choose a database (press Enter to skip)",
+        options: DATABASE_OPTIONS,
+        initial: [], // indices
+    });
+    if (typeof dbChoices === "symbol" || isCancel(dbChoices))
+        return cancel("Aborted.");
+    const db = dbChoices[0];
+    // i18n
+    const i18n = await select({
+        message: "Enable i18n?",
+        options: [
+            { label: "Yes", value: "yes" },
+            { label: "No", value: "no" },
+        ],
+        initial: 1,
+    });
+    if (typeof i18n === "symbol" || isCancel(i18n))
+        return cancel("Aborted.");
+    const withI18n = i18n === "yes";
+    // sessions
+    const sessions = await select({
+        message: "Configure sessions?",
+        options: [
+            { label: "Yes", value: "yes" },
+            { label: "No", value: "no" },
+        ],
+        initial: 1,
+    });
+    if (typeof sessions === "symbol" || isCancel(sessions))
+        return cancel("Aborted.");
+    const withSessions = sessions === "yes";
+    // scaffold dirs
+    await target.create({ recursive: true });
+    await target.join("routes").create({ recursive: true });
+    await target.join("components").create({ recursive: true });
+    if (db)
+        await target.join("stores").create({ recursive: true });
+    // files
+    await gitignore(target);
+    await tsconfig_json(target);
+    await app_config(target, { fronts, backs, runtime });
+    if (withI18n)
+        await i18n_config(target);
+    if (withSessions)
+        await session_config(target);
+    if (db)
+        await database_config(target, db);
+    await package_json(target, { directory, runtime });
+    const packages = compute_packages({ fronts, backs, db });
+    const install = buildInstallCommand(runtime, packages, directory);
+    outro([
+        "Done, now run",
+        `\n  ${install.print}`,
+    ].join("\n"));
+    process.exit();
+}
+async function empty(directory) {
+    try {
+        if (!(await directory.exists()))
+            return true;
+        const entries = await directory.list();
+        return entries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitignore(root) {
+    const gi = root.join(".gitignore");
+    await gi.directory.create({ recursive: true });
+    const content = [
+        "node_modules",
+        "build",
+        "dist",
+        ".DS_Store",
+        "*.log",
+        "npm-debug.log*",
+        "yarn-debug.log*",
+        "yarn-error.log*",
+        "pnpm-debug.log*",
+        "",
+    ].join("\n");
+    await gi.write(content);
+}
+async function app_config(root, c) {
+    const cfg = root.join("config").join("app.ts");
+    await cfg.directory.create({ recursive: true });
+    const frontendImports = c.fronts
+        .map((f) => `import ${toIdent(f)} from "@primate/${f}";`)
+        .join("\n");
+    const backendImports = c.backs
+        .map((b) => `import ${toIdent(b)} from "@primate/${b}";`)
+        .join("\n");
+    const modules = [
+        ...c.fronts.map((f) => `${toIdent(f)}()`),
+        ...c.backs.map((b) => `${toIdent(b)}()`),
+    ];
+    const body = dedent `import config from "primate/config";
+${frontendImports}
+${backendImports}
+
+export default config({
+  runtime: "${c.runtime}",
+  modules: [
+    ${modules.join(",\n    ")}
+  ],
+});
+`;
+    await cfg.write(body);
+}
+// i18n scaffold: config + a default locale file
+async function i18n_config(root) {
+    const locales = root.join("locales");
+    const en_us = locales.join("en-US.ts");
+    const i18i = root.join("config").join("i18n.ts");
+    await en_us.directory.create({ recursive: true });
+    await i18i.directory.create({ recursive: true });
+    const locale = `import locale from "primate/i18n/locale";
+
+export default locale({
+  hi: "Hello",
+  placeheld: "Hello, {name}",
+});
+`;
+    await en_us.write(locale);
+    const config = `import en from "#locale/en-US";
+import i18n from "primate/config/i18n";
+
+export default i18n({
+  defaultLocale: "en-US",
+  locales: {
+    "en-US": en,
+  },
+});
+`;
+    await i18i.write(config);
+}
+async function session_config(root) {
+    const file = root.join("config").join("session.ts");
+    await file.directory.create({ recursive: true });
+    const body = `import session from "primate/config/session";
+
+export default session({});
+`;
+    await file.write(body);
+}
+async function database_config(root, db) {
+    const file = root.join("config").join("database").join("index.ts");
+    await file.directory.create({ recursive: true });
+    const ident = toIdent(db);
+    const body = `import ${ident} from "@primate/${db}";
+
+export default ${ident}();
+`;
+    await file.write(body);
+}
+async function package_json(root, c) {
+    const pkgFile = root.join("package.json");
+    const pkg = {
+        name: safe(c.directory),
+        type: "module",
+        scripts: {},
+    };
+    if (c.runtime === "deno") {
+        pkg.scripts.start = "deno run -A npm:primate";
+        pkg.scripts.build = "deno run -A npm:primate build";
+        pkg.scripts.serve = "deno run -A npm:primate serve";
+        pkg.scripts.dev = "deno task start";
+    }
+    else if (c.runtime === "bun") {
+        pkg.scripts.start = "bunx --bun primate";
+        pkg.scripts.build = "bunx --bun primate build";
+        pkg.scripts.serve = "bunx --bun primate serve";
+        pkg.scripts.dev = "bun run start";
+    }
+    else {
+        pkg.scripts.start = "npx primate";
+        pkg.scripts.build = "npx primate build";
+        pkg.scripts.serve = "npx primate serve";
+        pkg.scripts.dev = "npm run start";
+    }
+    await pkgFile.writeJSON(pkg);
+}
+function safe(s) {
+    return s.trim().toLowerCase().replace(/\s+/g, "-")
+        .replace(/[^a-z0-9._-]/g, "") || "primate-app";
+}
+function toIdent(token) {
+    // turn tokens like "web-components" into valid identifiers: "web_components"
+    return token.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function compute_packages(args) {
+    const deps = new Set();
+    const devDeps = new Set();
+    deps.add("primate");
+    // Always add TypeScript as dev dependency
+    devDeps.add("typescript");
+    // frontends → @primate/<token> (+ peer deps)
+    for (const f of args.fronts) {
+        deps.add(`@primate/${f}`);
+        const extras = FRONTEND_PEER_DEPS[f] || [];
+        for (const extra of extras)
+            deps.add(extra);
+    }
+    // backends → @primate/<token>
+    for (const b of args.backs) {
+        deps.add(`@primate/${b}`);
+    }
+    // database → @primate/<token>, if selected
+    if (args.db)
+        deps.add(`@primate/${args.db}`);
+    return {
+        dependencies: Array.from(deps),
+        devDependencies: Array.from(devDeps),
+    };
+}
+function shQuote(p) {
+    // POSIX shell-safe quoting
+    return `'${p.replace(/'/g, "'\\''")}'`;
+}
+function buildInstallCommand(runtime, packages, dir) {
+    const { dependencies, devDependencies } = packages;
+    const allPkgs = [...dependencies, ...devDependencies];
+    if (allPkgs.length === 0) {
+        return { print: "No packages to install.", run: "" };
+    }
+    const cd = `cd ${shQuote(dir)} && `;
+    if (runtime === "bun") {
+        const depCmd = dependencies.length > 0 ? `bun add ${dependencies.join(" ")}` : "";
+        const devCmd = devDependencies.length > 0 ? `bun add -d ${devDependencies.join(" ")}` : "";
+        const commands = [depCmd, devCmd].filter(Boolean);
+        return { print: cd + commands.join(" && "), run: "" };
+    }
+    if (runtime === "deno") {
+        const inner = `deno add ${allPkgs.map((p) => `npm:${p}`).join(" ")}`;
+        return { print: cd + inner, run: "" };
+    }
+    // default: Node
+    const depCmd = dependencies.length > 0 ? `npm install ${dependencies.join(" ")}` : "";
+    const devCmd = devDependencies.length > 0 ? `npm install -D ${devDependencies.join(" ")}` : "";
+    const commands = [depCmd, devCmd].filter(Boolean);
+    return { print: cd + commands.join(" && "), run: "" };
+}
+async function tsconfig_json(root) {
+    await root.join("tsconfig.json").writeJSON({
+        extends: "primate/tsconfig",
+    });
+}
+//# sourceMappingURL=init.js.map

package/lib/commands/serve.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<any>;
+export default _default;
+//# sourceMappingURL=serve.d.ts.map

package/lib/commands/serve.js

@@ -0,0 +1,13 @@
+import FileRef from "@rcompat/fs/FileRef";
+import root from "@rcompat/package/root";
+const load = async () => {
+    try {
+        return await root();
+    }
+    catch {
+        return FileRef.resolve();
+    }
+};
+// serve from build directory
+export default async () => (await load()).join("./build/serve.js").import();
+//# sourceMappingURL=serve.js.map

package/lib/commands/test.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=test.d.ts.map

package/lib/commands/test.js

@@ -0,0 +1,133 @@
+import { tests } from "#test";
+import build from "@primate/core/build";
+import green from "@rcompat/cli/color/green";
+import red from "@rcompat/cli/color/red";
+import root from "@rcompat/package/root";
+import entries from "@rcompat/record/entries";
+import equals from "@rcompat/test/equals";
+import includes from "@rcompat/test/includes";
+import serve from "./serve.js";
+const directory = "test";
+const fetch_options = { redirect: "manual" };
+const first_error = (left, right) => {
+    const length = left.length > right.length ? right.length : left.length;
+    for (let i = 0; i < length; i++) {
+        if (left[i] !== right[i]) {
+            return i;
+        }
+    }
+};
+export default async () => {
+    await build("testing", "web");
+    const app = (await serve()).default;
+    const files = await (await root()).join(directory)
+        .list(({ path }) => path.endsWith(".ts") || path.endsWith(".js"));
+    // side effects
+    await Promise.all(files.map(file => file.import()));
+    for (const test of tests) {
+        let init;
+        let path;
+        const route = test.route;
+        if (typeof route === "string") {
+            path = route;
+            init = new Request(`${app.url}${route}`);
+        }
+        else {
+            path = route.url.replace(app.url, "");
+            init = new Request(route.url, {
+                body: route.body,
+                // @ts-expect-error nonsense
+                duplex: "half",
+                headers: route.headers,
+                method: route.method,
+            });
+        }
+        const response = await fetch(init, fetch_options);
+        const checks = [];
+        const mocked_response = {
+            body: {
+                equals(expected) {
+                    checks.push(async () => {
+                        const actual = await (typeof expected === "string"
+                            ? response.text()
+                            : response.json());
+                        return [equals(actual, expected), expected, actual];
+                    });
+                },
+                includes(expected) {
+                    checks.push(async () => {
+                        const actual = await (typeof expected === "string"
+                            ? response.text()
+                            : response.json());
+                        const $expected = typeof expected === "string"
+                            ? expected.replaceAll("\n", "").replaceAll("  ", "")
+                            : expected;
+                        return [includes(actual, $expected), $expected, actual];
+                    });
+                },
+            },
+            headers: {
+                get(name) {
+                    const actual = response.headers.get(name);
+                    return {
+                        equals(expected) {
+                            checks.push(() => {
+                                return [equals(actual, expected), expected, actual];
+                            });
+                        },
+                        includes(expected) {
+                            checks.push(() => {
+                                return [includes(actual, expected), expected, actual];
+                            });
+                        },
+                    };
+                },
+                includes(expected) {
+                    checks.push(() => {
+                        const actual = Object.fromEntries(response.headers.entries());
+                        const lowercased = entries(expected)
+                            .keymap(([key]) => key.toLowerCase()).get();
+                        return [includes(actual, lowercased), lowercased, actual];
+                    });
+                },
+            },
+            status: {
+                equals(status) {
+                    checks.push(() => {
+                        return [response.status === status, status, response.status];
+                    });
+                },
+            },
+        };
+        test.tester(mocked_response);
+        const results = await Promise.all(checks.map(async (check) => {
+            try {
+                return await check();
+            }
+            catch (error) {
+                console.log(error);
+                return [
+                    false, "()", "test execution failed",
+                ];
+            }
+        }));
+        const failed = results.find(result => !result[0]);
+        const verb = test.verb.toUpperCase();
+        if (failed !== undefined) {
+            const routeText = typeof test.route === "string"
+                ? test.route
+                : new URL(test.route.url).pathname;
+            console.log(red(`${verb} ${routeText}`));
+            const expected = JSON.stringify(failed[1]);
+            const actual = JSON.stringify(failed[2]);
+            const n = first_error(expected, actual);
+            console.log(`expected: ${expected.slice(0, n)}${green(expected[n])}${expected.slice(n + 1)}`);
+            console.log(`actual:   ${actual.slice(0, n)}${red(actual[n])}${actual.slice(n + 1)}`);
+        }
+        else {
+            console.log(green(`${verb} ${path}`));
+        }
+    }
+    await app.stop();
+};
+//# sourceMappingURL=test.js.map

package/lib/init.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (...args: string[]) => Promise<void>;
+export default _default;
+//# sourceMappingURL=init.d.ts.map

package/lib/init.js

@@ -0,0 +1,12 @@
+import blue from "@rcompat/cli/color/blue";
+import bold from "@rcompat/cli/color/bold";
+import print from "@rcompat/cli/print";
+import json from "@rcompat/package/json";
+import find from "./commands/index.js";
+export default async (...args) => {
+    const [command, ...flags] = args;
+    const { name, version, } = await (await json(import.meta.url)).json();
+    print(blue(bold(name)), blue(version), "\n");
+    find(command)(flags);
+};
+//# sourceMappingURL=init.js.map

package/lib/private/test.d.ts

@@ -0,0 +1,32 @@
+import verbs from "@primate/core/request/verbs";
+import type Dict from "@rcompat/type/Dict";
+import type JSONValue from "@rcompat/type/JSONValue";
+export type Body = JSONValue;
+export type MockedResponse = {
+    body: {
+        equals(body: Body): void;
+        includes(body: Body): void;
+    };
+    headers: {
+        get(header: string): {
+            equals(value: string): void;
+            includes(value: string): void;
+        };
+        includes(headers: Dict<string>): void;
+    };
+    status: {
+        equals(status: number): void;
+    };
+};
+type Verb = typeof verbs[number];
+type Tester = (response: MockedResponse) => void;
+type Route = string;
+type Test = {
+    route: Request | Route;
+    tester: Tester;
+    verb: Verb;
+};
+export declare const tests: Test[];
+declare const _default: { [K in Verb]: (path: Request | Route, tester: Tester) => void; };
+export default _default;
+//# sourceMappingURL=test.d.ts.map