@primate/core 0.3.4 → 0.4.1

package/lib/private/hook/build.js

@@ -1,260 +0,0 @@
-import fail from "#fail";
-import location from "#location";
-import log from "#log";
-import reducer from "#reducer";
-import $router from "#request/router";
-import wrap from "#route/wrap";
-import s_layout_depth from "#symbol/layout-depth";
-import FileRef from "@rcompat/fs/FileRef";
-import json from "@rcompat/package/json";
-import dedent from "@rcompat/string/dedent";
-const dirname = import.meta.dirname;
-const pre = async (app) => {
-    // remove build directory in case exists
-    await app.path.build.remove();
-    await app.path.build.create();
-    await Promise.all(["server", "client", "views"]
-        .map(directory => app.runpath(directory).create()));
-    // this has to occur before post, so that layout depth is available for
-    // compiling root views
-    // bindings should have been registered during `init`
-    const router = await $router(app.path.routes, app.extensions);
-    app.set(s_layout_depth, router.depth("layout"));
-    const i18n_config_path = app.path.config.join("i18n.ts");
-    const i18n_config_js_path = app.path.config.join("i18n.js");
-    // minimal effort: check if i18n.ts exists (heavier effort during serve)
-    const has_i18n_config = await i18n_config_path.exists()
-        || await i18n_config_js_path.exists();
-    app.i18n_active = has_i18n_config;
-    return app;
-};
-async function index_database(base) {
-    // app/config/database does not exist -> use prelayered default
-    if (!await base.exists())
-        return "";
-    const databases = await base.list();
-    const n = databases.length;
-    // none in app/config/database -> use prelayered default
-    if (n === 0)
-        return "";
-    const names = databases.map(d => d.name);
-    // index database file found, will be overwritten in next step -> do nothing
-    if (names.includes("index.ts") || names.includes("index.js")) {
-        return ""; // empty string means: don't generate, user provided own
-    }
-    // app/config/default.ts -> reexport
-    if (names.includes("default.ts")) {
-        return "export { default } from \"./default.js\";";
-    }
-    // app/config/default.js -> reexport
-    if (names.includes("default.js")) {
-        return "export { default } from \"./default.js\";";
-    }
-    // exactly one in app/config/database -> reexport that
-    if (n === 1) {
-        const onlyFile = names[0];
-        const withoutExt = onlyFile.replace(/\.(ts|js)$/, ".js");
-        return `export { default } from "./${withoutExt}";`;
-    }
-    // multiple files, none is index or default -> error
-    throw fail("multiple database drivers, add index or default.(ts|js); found {0}", names.join(", "));
-}
-const js_re = /^.*.js$/;
-const write_directories = async (build_directory, app) => {
-    for (const name of app.server_build) {
-        const d = app.runpath(`${name}s`);
-        const e = await Promise.all((await FileRef.collect(d, file => js_re.test(file.path)))
-            .map(async (path) => `${path}`.replace(d.toString(), _ => "")));
-        const files_js = `
-    const ${name} = [];
-    ${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `const ${name}${i} = (await import("${FileRef.webpath(`#${name}/${bare}`)}")).default;
-    ${name}.push(["${FileRef.webpath(bare)}", ${name}${i}]);`).join("\n")}
-    export default ${name};`;
-        await build_directory.join(`${name}s.js`).write(files_js);
-    }
-};
-const write_stores = async (build_directory, app) => {
-    const d2 = app.runpath(location.stores);
-    const e = await Promise.all((await FileRef.collect(d2, file => js_re.test(file.path)))
-        .map(async (path) => `${path}`.replace(d2.toString(), _ => "")));
-    const stores_js = `
-const store = [];
-${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as store${i} from "${FileRef.webpath(`#store/${bare}`)}";
-store.push(["${FileRef.webpath(bare)}", store${i}]);`).join("\n")}
-
-export default store;`;
-    await build_directory.join("stores.js").write(stores_js);
-};
-const write_views = async (build_directory, app) => {
-    const d2 = app.runpath(location.views);
-    const e = await Promise.all((await FileRef.collect(d2, file => js_re.test(file.path)))
-        .map(async (path) => `${path}`.replace(d2.toString(), _ => "")));
-    const views_js = `
-const view = [];
-${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as view${i} from "${FileRef.webpath(`#view/${bare}`)}";
-view.push(["${FileRef.webpath(bare)}", view${i}]);`).join("\n")}
-
-${app.roots.map((root, i) => `
-import * as root${i} from "${FileRef.webpath(`../server/${root.name}`)}";
-view.push(["${root.name.slice(0, -".js".length)}", root${i}]);
-`).join("\n")}
-
-export default view;`;
-    await build_directory.join("views.js").write(views_js);
-};
-const write_bootstrap = async (app, mode, i18n_active) => {
-    const build_start_script = `
-import serve from "primate/serve";
-const files = {};
-${app.server_build.map(name => `${name}s`).map(name => `import ${name} from "./${app.id}/${name}.js";
-     files.${name} = ${name};`).join("\n")}
-import views from "./${app.id}/views.js";
-import stores from "./${app.id}/stores.js";
-import target from "./target.js";
-import session from "#session";
-import config from "#config";
-import s_config from "primate/symbol/config";
-
-${i18n_active ? `
-import t from "#i18n";
-const i18n_config = t[s_config];
-` : `
-const i18n_config = undefined;
-`}
-
-const app = await serve(import.meta.url, {
-  ...target,
-  config,
-  files,
-  views,
-  stores,
-  mode: "${mode}",
-  session_config: session[s_config],
-  i18n_config,
-});
-
-export default app;
-`;
-    await app.path.build.join("serve.js").write(build_start_script);
-};
-const post = async (app) => {
-    const defaults = FileRef.join(import.meta.url, "../../defaults");
-    await app.compile(app.path.routes, "routes", {
-        loader: (source, file) => {
-            const path = app.basename(file, app.path.routes);
-            return wrap(source, path, app.id);
-        },
-    });
-    await app.compile(app.path.stores, "stores", {
-        resolver: basename => `${basename}.original`, // First pass: save original
-    });
-    if (await app.path.stores.exists()) {
-        const stores = await app.path.stores.collect(({ path }) => app.extensions.some(e => path.endsWith(e)));
-        for (const file of stores) {
-            const basename = app.basename(file, app.path.stores);
-            const wrapper = dedent `
-        import database from "#database";
-        import store from "./${basename}.original.js";
-        import wrap from "primate/database/wrap";
-        export default wrap("${basename}", store, database);
-      `;
-            const target = app.runpath("stores", `${basename}.js`);
-            await target.write(wrapper);
-        }
-    }
-    const configs = FileRef.join(dirname, "../../private/config/config");
-    const database_base = app.path.config.join("database");
-    // prelayer config default
-    await app.compile(configs, "config", {
-        loader: async (source, file) => {
-            const relative = file.debase(configs);
-            if (relative.path === "/database/index.js") {
-                const indexContent = await index_database(database_base);
-                // if empty, user provided own index -> use the compiled source
-                return indexContent || source;
-            }
-            return source;
-        },
-    });
-    await app.compile(app.path.modules, "modules");
-    await app.compile(app.path.locales, "locales");
-    await app.compile(app.path.config, "config");
-    // reusable components
-    await app.compile(app.path.components, "components");
-    // view components
-    await app.compile(app.path.views, "views");
-    // copy framework pages
-    await defaults.copy(app.runpath(location.server, location.pages));
-    // copy pages to build
-    if (await app.path.pages.exists()) {
-        await app.path.pages.copy(app.runpath(location.server, location.pages));
-    }
-    if (await app.path.static.exists()) {
-        // copy static files to build/static
-        await app.path.static.copy(app.runpath(location.static));
-    }
-    // publish JavaScript and CSS files
-    const imports = await FileRef.collect(app.path.static, file => /\.(?:js|ts|css)$/.test(file.path));
-    await Promise.all(imports.map(async (file) => {
-        const src = file.debase(app.path.static);
-        app.build.export(`import "./${location.static}${src}";`);
-    }));
-    app.build.export("import \"primate/client/app\";");
-    app.build.plugin({
-        name: "@primate/core/frontend",
-        setup(build) {
-            build.onResolve({ filter: /#frontends/ }, ({ path }) => {
-                return { namespace: "frontends", path };
-            });
-            build.onLoad({ filter: /#frontends/ }, async () => {
-                const contents = [...app.frontends.keys()].map(name => `export { default as ${name} } from "@primate/${name}";`).join("\n");
-                return { contents, resolveDir: app.root.path };
-            });
-        },
-    });
-    app.build.plugin({
-        name: "@primate/core/alias",
-        setup(build) {
-            build.onResolve({ filter: /#static/ }, args => {
-                const path = args.path.slice(1);
-                return { path: app.root.join(path).path };
-            });
-        },
-    });
-    // start the build
-    await app.build.start();
-    // a target needs to create an `assets.js` that exports assets
-    await app.target.run();
-    const build_directory = app.path.build.join(app.id);
-    // TODO: remove after rcompat automatically creates directories
-    await build_directory.create();
-    await write_views(build_directory, app);
-    await write_stores(build_directory, app);
-    await write_directories(build_directory, app);
-    await write_bootstrap(app, app.mode, app.i18n_active);
-    const manifest_data = {
-        ...await (await json()).json(),
-        type: "module",
-        imports: {
-            "#config": "./config/app.js",
-            "#config/*": "./config/*.js",
-            "#database": "./config/database/index.js",
-            "#database/*": "./config/database/*.js",
-            "#session": "./config/session.js",
-            "#i18n": "./config/i18n.js",
-            "#view/*": "./views/*.js",
-            "#component/*": "./components/*.js",
-            "#locale/*": "./locales/*.js",
-            "#module/*": "./modules/*.js",
-            "#route/*": "./routes/*.js",
-            "#store/*": "./stores/*.js",
-        },
-    };
-    // create package.json
-    await app.path.build.join("package.json").writeJSON(manifest_data);
-    log.system("build written to {0}", app.path.build);
-    app.cleanup();
-    return app;
-};
-export default async (app) => post(await reducer(app.modules, await pre(app), "build"));
-//# sourceMappingURL=build.js.map

package/lib/private/serve.d.ts

@@ -1,5 +0,0 @@
-import ServeApp from "#ServeApp";
-import type ServeInit from "#ServeInit";
-declare const _default: (root: string, options: ServeInit) => Promise<ServeApp>;
-export default _default;
-//# sourceMappingURL=serve.d.ts.map

package/lib/private/serve.js

@@ -1,8 +0,0 @@
-import serve from "#hook/serve";
-import ServeApp from "#ServeApp";
-export default async (root, options) => {
-    const app = await new ServeApp(root, options)
-        .init(options.target);
-    return serve(app);
-};
-//# sourceMappingURL=serve.js.map

package/lib/private/session/InMemoryManager.d.ts

@@ -1,9 +0,0 @@
-import SessionManager from "#session/Manager";
-export default class InMemorySessionManager<Data> extends SessionManager<Data> {
-    #private;
-    load(id: string): Data | undefined;
-    create(id: string, data: Data): void;
-    save(id: string, data: Data): void;
-    destroy(id: string): void;
-}
-//# sourceMappingURL=InMemoryManager.d.ts.map

package/lib/private/session/InMemoryManager.js

@@ -1,23 +0,0 @@
-import SessionManager from "#session/Manager";
-import assert from "@rcompat/assert";
-export default class InMemorySessionManager extends SessionManager {
-    // id -> JSON
-    #sessions = new Map();
-    load(id) {
-        const raw = this.#sessions.get(id);
-        return raw === undefined ? undefined : JSON.parse(raw);
-    }
-    create(id, data) {
-        assert(!this.#sessions.has(id), `session already exists: ${id}`);
-        this.#sessions.set(id, JSON.stringify(data));
-    }
-    save(id, data) {
-        assert(this.#sessions.has(id), `session not found: ${id}`);
-        this.#sessions.set(id, JSON.stringify(data));
-    }
-    // idempotent
-    destroy(id) {
-        this.#sessions.delete(id);
-    }
-}
-//# sourceMappingURL=InMemoryManager.js.map

package/lib/private/session/Manager.d.ts

@@ -1,9 +0,0 @@
-import type MaybePromise from "@rcompat/type/MaybePromise";
-export default abstract class SessionManager<Data> {
-    init?(): MaybePromise<void>;
-    abstract load(id: string): MaybePromise<Data | undefined>;
-    abstract create(id: string, data: Data): MaybePromise<void>;
-    abstract save(id: string, data: Data): MaybePromise<void>;
-    abstract destroy(id: string): MaybePromise<void>;
-}
-//# sourceMappingURL=Manager.d.ts.map

package/lib/private/session/Manager.js

@@ -1,4 +0,0 @@
-export default class SessionManager {
-    init() { }
-}
-//# sourceMappingURL=Manager.js.map

package/lib/private/target/web.d.ts

@@ -1,4 +0,0 @@
-import type Target from "#target/Target";
-declare const web: Target;
-export default web;
-//# sourceMappingURL=web.d.ts.map

package/lib/private/target/web.js

@@ -1,58 +0,0 @@
-import location from "#location";
-import FileRef from "@rcompat/fs/FileRef";
-const html = /^.*.html$/ui;
-const web = {
-    name: "web",
-    runner: async (app) => {
-        const client = app.runpath(location.client);
-        const client_imports = (await client.collect())
-            .map((file, i) => {
-            const type = file.extension === ".css" ? "style" : "js";
-            const src = `/${file.debase(client).name}`;
-            const path = `./${file.debase(`${app.path.build}/`)}`;
-            return {
-                code: `await load_text(asset${i})`,
-                path,
-                src,
-                type,
-            };
-        });
-        const d = app.runpath(location.server, location.pages);
-        const pages = await Promise.all((await FileRef.collect(d, file => html.test(file.path)))
-            .map(async (file) => `${file.debase(d)}`.slice(1)));
-        const pages_str = pages.map(page => `"${page}": await load_text(import.meta.url,
-    "${FileRef.webpath(`../${location.server}/${location.pages}/${page}`)}"),`)
-            .join("\n");
-        const assets_scripts = `
-  import Loader from "primate/Loader";
-  import load_text from "primate/load-text";
-
-  ${client_imports.map(({ path }, i) => `const asset${i} = await load_text(import.meta.url, "../${path}");`)
-            .join("\n  ")}
-  const assets = [${client_imports.map(($import, i) => `{
-  src: "${$import.src}",
-  code: asset${i},
-  type: "${$import.type}",
-  inline: false,
-  }`).join(",\n  ")}];
-
-  const pages = {
-    ${pages_str}
-  };
-
-  export default {
-    assets,
-    loader: new Loader({
-      pages,
-      rootfile: import.meta.url,
-      static_root: "${app.config("http.static.root")}",
-    }),
-    target: "web",
-  };
-`;
-        await app.path.build.join("target.js").write(assets_scripts);
-    },
-    target: "web",
-};
-export default web;
-//# sourceMappingURL=web.js.map

package/lib/public/Loader.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#Loader";
-//# sourceMappingURL=Loader.d.ts.map

package/lib/public/Loader.js

@@ -1,2 +0,0 @@
-export { default } from "#Loader";
-//# sourceMappingURL=Loader.js.map

package/lib/public/session/Manager.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#session/Manager";
-//# sourceMappingURL=Manager.d.ts.map

package/lib/public/session/Manager.js

@@ -1,2 +0,0 @@
-export { default } from "#session/Manager";
-//# sourceMappingURL=Manager.js.map