@primate/native 0.1.6 → 0.2.0

package/lib/private/Loader.d.ts

@@ -0,0 +1,17 @@
+import Loader from "@primate/core/Loader";
+import type Dict from "@rcompat/type/Dict";
+type Init = {
+    client_imports: Dict<string>;
+    pages: Dict<string>;
+    pages_app: string;
+    rootfile: string;
+    static_imports: Dict<string>;
+    static_root: string;
+};
+export default class NativeLoader extends Loader {
+    #private;
+    constructor(init: Init);
+    serve(pathname: string): Promise<Response | undefined>;
+}
+export {};
+//# sourceMappingURL=Loader.d.ts.map

package/lib/private/Loader.js

@@ -0,0 +1,28 @@
+import Loader from "@primate/core/Loader";
+import FileRef from "@rcompat/fs/FileRef";
+import entries from "@rcompat/record/entries";
+export default class NativeLoader extends Loader {
+    #clients = {};
+    #statics = {};
+    constructor(init) {
+        super(init);
+        this.#clients = entries(init.client_imports)
+            .valmap(([, url]) => new FileRef(url)).get();
+        this.#statics = entries(init.static_imports)
+            .valmap(([, url]) => new FileRef(url)).get();
+    }
+    async serve(pathname) {
+        const client_file = this.#clients[pathname];
+        if (client_file !== undefined) {
+            return this.asset(client_file);
+        }
+        if (pathname.startsWith(this.static_root)) {
+            const assetname = pathname.slice(this.static_root.length);
+            const static_file = this.#statics[assetname];
+            if (static_file !== undefined) {
+                return this.asset(static_file);
+            }
+        }
+    }
+}
+//# sourceMappingURL=Loader.js.map

package/lib/private/Module.d.ts

@@ -0,0 +1,25 @@
+import type App from "@primate/core/App";
+import type BuildApp from "@primate/core/BuildApp";
+import Module from "@primate/core/Module";
+import type Next from "@primate/core/Next";
+import type NextBuild from "@primate/core/NextBuild";
+import type NextServe from "@primate/core/NextServe";
+import type ServeApp from "@primate/core/ServeApp";
+declare const schema: import("pema").ObjectType<{
+    debug: import("pema").DefaultType<import("pema/boolean").BooleanType, false>;
+    start: import("pema").DefaultType<import("pema/string").StringType, "/">;
+}>;
+export default class NativeModule extends Module {
+    #private;
+    name: string;
+    static input: {
+        debug?: boolean | undefined;
+        start?: string | undefined;
+    } | undefined;
+    constructor(config: typeof schema.input);
+    init<T extends App>(app: T, next: Next<T>): import("@rcompat/type/MaybePromise").default<T>;
+    build(app: BuildApp, next: NextBuild): import("@rcompat/type/MaybePromise").default<BuildApp>;
+    serve(app: ServeApp, next: NextServe): import("@rcompat/type/MaybePromise").default<ServeApp>;
+}
+export {};
+//# sourceMappingURL=Module.d.ts.map

package/lib/private/Module.js

@@ -0,0 +1,62 @@
+import command from "#command";
+import targets from "#targets";
+import log from "@primate/core/log";
+import Module from "@primate/core/Module";
+import dim from "@rcompat/cli/color/dim";
+import execute from "@rcompat/stdio/execute";
+import pema from "pema";
+import boolean from "pema/boolean";
+import string from "pema/string";
+const names = targets.map(t => t.name);
+const schema = pema({
+    debug: boolean.default(false),
+    start: string.default("/"),
+});
+export default class NativeModule extends Module {
+    name = "native";
+    #config;
+    static input = schema.input;
+    constructor(config) {
+        super();
+        this.#config = schema.parse(config);
+    }
+    init(app, next) {
+        targets.forEach(t => app.target.add(t));
+        return next(app);
+    }
+    build(app, next) {
+        if (names.includes(app.target.name)) {
+            app.done(async () => {
+                const { exe, flags } = app.target.get();
+                const executable_path = dim(`${app.path.build}/${exe}`);
+                const { host, port } = app.config("http");
+                await app.runpath("worker.js").write(`
+          import target from "@primate/native/target/${app.target.target}";
+          import Webview from "@primate/native/Webview";
+          const webview = new Webview({ platform: target });
+          webview.navigate("http://${host}:${port}/${this.#config.start}");
+          webview.run();
+        `);
+                await execute(command({
+                    exe,
+                    files: ["serve.js", "worker.js"],
+                    flags,
+                }));
+                log.system("executable written to {0}", executable_path);
+            });
+        }
+        return next(app);
+    }
+    serve(app, next) {
+        if (names.includes(app.target.name)) {
+            const worker = new Worker(app.root.join("worker.js").path);
+            worker.addEventListener("message", event => {
+                if (event.data === "destroyed") {
+                    app.stop();
+                }
+            });
+        }
+        return next(app);
+    }
+}
+//# sourceMappingURL=Module.js.map

package/lib/private/NativeTarget.d.ts

@@ -0,0 +1,6 @@
+import type Target from "@primate/core/Target";
+export default interface NativeTarget extends Target {
+    exe: string;
+    flags: string;
+}
+//# sourceMappingURL=NativeTarget.d.ts.map

package/lib/private/NativeTarget.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=NativeTarget.js.map

package/lib/private/command.d.ts

@@ -0,0 +1,8 @@
+type Init = {
+    exe: string;
+    files: string[];
+    flags: string;
+};
+export default function (init: Init): string;
+export {};
+//# sourceMappingURL=command.d.ts.map

package/lib/private/command.js

@@ -0,0 +1,23 @@
+import AppError from "@primate/core/AppError";
+import runtime from "@rcompat/runtime";
+const commands = {
+    bun: "bun build",
+    deno: "deno compile",
+};
+function which(target) {
+    if (target in commands) {
+        return commands[target];
+    }
+    throw new AppError("unsupported runtime {0}", target);
+}
+;
+export default function (init) {
+    return `
+    ${which(runtime)} \
+    ${init.files.map(file => `build/${file}`).join(" ")} \
+    --conditions=runtime --compile --minify \
+    ${init.flags} \
+    --outfile build/${init.exe}
+  `;
+}
+//# sourceMappingURL=command.js.map

package/lib/private/desktop.d.ts

@@ -0,0 +1,4 @@
+import type App from "@primate/core/App";
+declare const _default: (app: App) => Promise<void>;
+export default _default;
+//# sourceMappingURL=desktop.d.ts.map

package/lib/private/desktop.js

@@ -0,0 +1,95 @@
+import location from "@primate/core/location";
+import FileRef from "@rcompat/fs/FileRef";
+import dedent from "@rcompat/string/dedent";
+const html = /^.*.html$/u;
+export default async (app) => {
+    const server_static = app.runpath(location.server, location.static);
+    // explicitly import static assets as files
+    const static_imports = (await server_static.collect()).map((path, i) => dedent `
+      import static${i} from
+        "${FileRef.webpath(`./server/static${path.debase(server_static)}`)}"
+        with { type: "file" };
+       static_imports["${FileRef
+        .webpath(path.debase(server_static))}"] = static${i};
+    `)
+        .join("\n");
+    const client = app.runpath(location.client);
+    // explicitly import client assets as files
+    const client_imports = (await Promise.all((await client.collect())
+        .map(async (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 FileRef.text(asset${i})`,
+            empty: (await file.text()).length === 0,
+            path,
+            src,
+            type,
+        };
+    }))).filter(file => !file.empty);
+    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}`.replace(`${d}/`, _ => "")));
+    const app_js = client_imports.find($import => $import.src.endsWith(".js"));
+    const assets_scripts = dedent `
+    import Webview from "@primate/native/target/${app.target.target}";
+    import Loader from "@primate/native/Loader";
+    import FileRef from "@primate/native/FileRef";
+
+    const static_imports = {};
+    ${static_imports}
+
+    const client_imports = {};
+    ${client_imports.map(({ path, src }, i) => dedent `
+      import client${i} from "${path}" with { type: "file" };
+      client_imports["${FileRef.webpath(src)}"] = client${i};
+      const file${i} = await FileRef.text(client${i});
+    `).join("\n  ")}
+
+    const assets = [${client_imports.map(($import, i) => dedent `{
+    src: "${$import.src}",
+    code: file${i},
+    type: "${$import.type}",
+    inline: false,
+    }`).join(",\n  ")}];
+
+    ${app_js === undefined ? "" : dedent `
+      const imports = {
+       app: "${FileRef.join("/", client_imports.find($import => $import.src.includes("app") && $import.src.endsWith(".js")).src)
+        .webpath()}"
+      };
+      // importmap
+      assets.push({
+        inline: true,
+        code: { imports },
+        type: "importmap",
+      });
+    `}
+
+    const page_imports = {};
+    ${pages.map((page, i) => dedent `
+      import page${i} from "${FileRef.webpath(`./${location.server}/${location.pages}/${page}`)}" with { type: "file" };
+      page_imports["${page}"] = page${i};`).join("\n  ")}
+
+    const load = async resource_map =>
+      Object.fromEntries(await Promise.all(Object.entries(resource_map).map(
+        async ([key, url]) => [key, await FileRef.text(url)])));
+    const pages = await load(page_imports);
+
+    export default {
+      assets,
+      loader: new Loader({
+        pages,
+        rootfile: import.meta.url,
+        static_root: "${app.config("http.static.root")}",
+        client_imports,
+        static_imports,
+        Webview,
+      }),
+      target: "${app.target.name}",
+    };
+  `;
+    await app.path.build.join("target.js").write(assets_scripts);
+};
+//# sourceMappingURL=desktop.js.map

package/lib/private/targets.d.ts

@@ -0,0 +1,4 @@
+import type NativeTarget from "#NativeTarget";
+declare const targets: NativeTarget[];
+export default targets;
+//# sourceMappingURL=targets.d.ts.map

package/lib/private/targets.js

@@ -0,0 +1,37 @@
+import runner from "#desktop";
+const targets = [
+    {
+        exe: "app",
+        flags: "--target=bun-linux-x64",
+        name: "linux-x64",
+        runner,
+        target: "linux-x64",
+    },
+    {
+        exe: "app.exe",
+        flags: "--target=bun-windows-x64",
+        name: "windows-x64",
+        runner,
+        target: "windows-x64",
+    },
+    {
+        exe: "app",
+        flags: "--target=bun-darwin-x64",
+        name: "darwin-x64",
+        runner,
+        target: "darwin-x64",
+    },
+    {
+        exe: "app",
+        flags: "--target=bun-darwin-arm64",
+        name: "darwin-arm64",
+        runner,
+        target: "darwin-arm64",
+    },
+];
+targets.push({
+    ...targets.find(t => t.target === `${process.platform}-${process.arch}`),
+    name: "desktop",
+});
+export default targets;
+//# sourceMappingURL=targets.js.map

package/lib/public/FileRef.d.ts

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

package/lib/public/FileRef.js

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

package/lib/public/Loader.d.ts

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

package/lib/public/Loader.js

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

package/lib/public/Webview.d.ts

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

package/lib/public/Webview.js

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

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import Module from "#Module";
+declare const _default: (config?: typeof Module.input) => Module;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import Module from "#Module";
+export default (config) => new Module(config);
+//# sourceMappingURL=index.js.map

package/lib/public/target/darwin-arm64.d.ts

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

package/lib/public/target/darwin-arm64.js

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

package/lib/public/target/darwin-x64.d.ts

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

package/lib/public/target/darwin-x64.js

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

package/lib/public/target/default.d.ts

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

package/lib/public/target/default.js

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

package/lib/public/target/linux-x64.d.ts

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

package/lib/public/target/linux-x64.js

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

package/lib/public/target/windows-x64.d.ts

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

package/lib/public/target/windows-x64.js

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

package/package.json

@@ -1,31 +1,52 @@
 {
   "name": "@primate/native",
-  "version": "0.1.6",
-  "description": "Primate native applications",
-  "homepage": "https://primatejs.com/modules/native",
-  "bugs": "https://github.com/primatejs/primate/issues",
+  "version": "0.2.0",
+  "description": "Primate native",
+  "homepage": "https://primate.run/docs/native",
+  "bugs": "https://github.com/primate-run/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.spec.js"
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/primatejs/primate",
+    "url": "https://github.com/primate-run/primate",
     "directory": "packages/native"
   },
   "dependencies": {
-    "@rcompat/cli": "^0.5.1",
-    "@rcompat/fs": "^0.7.0",
-    "@rcompat/object": "^0.5.0",
-    "@rcompat/stdio": "^0.5.0",
-    "@rcompat/webview": "^0.8.0",
-    "@primate/core": "^0.1.9"
+    "@rcompat/cli": "^0.11.3",
+    "@rcompat/fs": "^0.21.1",
+    "@rcompat/record": "^0.9.1",
+    "@rcompat/runtime": "^0.6.0",
+    "@rcompat/stdio": "^0.12.2",
+    "@rcompat/string": "^0.10.0",
+    "@rcompat/webview": "^0.14.0",
+    "@primate/core": "^0.2.0",
+    "pema": "^0.2.0"
   },
   "type": "module",
+  "imports": {
+    "#*": {
+      "apekit": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
+    }
+  },
   "exports": {
-    ".": "./src/index.js",
-    "./*": "./src/public/*.js",
-    "./platform/*": "./src/platform/*.js"
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    },
+    "./*": {
+      "apekit": "./src/public/*.ts",
+      "default": "./lib/public/*.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npm run build && npx proby"
   }
 }

package/src/desktop.js

@@ -1,89 +0,0 @@
-import collect from "@rcompat/fs/collect";
-import join from "@rcompat/fs/join";
-import webpath from "@rcompat/fs/webpath";
-
-const html = /^.*.html$/u;
-
-export default async app => {
-  const location = app.get("location");
-  const client = app.runpath(location.client);
-  const server_static = app.runpath(location.server, location.static);
-  const re = /app..*(?:js|css)$/u;
-
-  const static_imports = (await server_static.collect()).map((path, i) => `
-    import static${i} from "${webpath(`./server/static${path.debase(server_static)}`)}" with { type: "file" };
-    static_imports["${webpath(path.debase(server_static))}"] = static${i};`)
-    .join("\n");
-
-  const client_imports = (await Promise.all((await client.collect())
-    .map(async (file, i) => {
-      const type = file.extension === ".css" ? "style" : "js";
-      const src = `/${file.debase(client).name}`;
-      const path = `./${file.debase(`${app.path.build}/`)}`;
-      return {
-        src,
-        path,
-        code: `await load_text(asset${i})`,
-        type,
-        empty: (await file.text()).length === 0,
-      };
-    }))).filter(file => !file.empty);
-  const d = app.runpath(location.server, location.pages);
-  const pages = await Promise.all((await collect(d, html, { recursive: true }))
-    .map(async file => `${file}`.replace(`${d}/`, _ => "")));
-  const app_js = client_imports.find($import => $import.src.endsWith(".js"));
-
-  const assets_scripts = `
-  import Webview from "@primate/native/platform/${app.build_target}";
-  import loader from "@primate/native/loader";
-  import load_text from "primate/load-text";
-
-  const static_imports = {};
-  ${static_imports}
-
-  const client_imports = {};
-  ${client_imports.map(({ path, src }, i) =>
-    `import client${i} from "${path}" with { type: "file" };
-    client_imports["${webpath(src)}"] = client${i};
-    const file${i} = await load_text(client${i});`).join("\n  ")}
-  const assets = [${client_imports.map(($import, i) => `{
-  src: "${$import.src}",
-  code: file${i},
-  type: "${$import.type}",
-  inline: false,
-  }`).join(",\n  ")}];
-
-  ${app_js === undefined ? "" :
-    `
-    const imports = {
-     app: "${join("/", client_imports.find($import =>
-    $import.src.includes("app") && $import.src.endsWith(".js")).src).webpath()}"
-    };
-    // importmap
-    assets.push({
-      inline: true,
-      code: { imports },
-      type: "importmap",
-    });`}
-
-  const page_imports = {};
-  ${pages.map((page, i) =>
-    `import page${i} from "${webpath(`./${location.server}/${location.pages}/${page}`)}" with { type: "file" };
-    page_imports["${page}"] = page${i};`).join("\n  ")}
-
-  export default {
-    assets,
-    loader: await loader({
-      page_imports,
-      client_imports,
-      static_imports,
-      pages_app: "${app.get("pages.app")}",
-      static_root: "${app.get("http.static.root")}",
-      Webview,
-    }),
-    target: "${app.build_target}",
-  };
-`;
-  await app.path.build.join("target.js").write(assets_scripts);
-
-};

package/src/index.js

@@ -1,44 +0,0 @@
-import dim from "@rcompat/cli/color/dim";
-import execute from "@rcompat/stdio/execute";
-import targets from "./targets.js";
-import log from "@primate/core/log";
-
-const target_keys = Object.keys(targets);
-const command = "bun build build/serve.js --conditions=runtime --compile --minify";
-
-export default ({
-  start = "/",
-  debug = false,
-} = {}) => {
-  return {
-    name: "primate:native",
-    init(app, next) {
-      target_keys.forEach(target => app.target(target, targets[target]));
-      return next(app);
-    },
-    build(app, next) {
-      if (target_keys.includes(app.build_target)) {
-        app.done(async () => {
-          const { flags, exe } = targets[app.build_target];
-          const executable_path = dim(`${app.path.build}/${exe}`);
-          await execute(`${command} ${flags} --outfile build/${exe}`);
-          log.system(`executable written to ${executable_path}`);
-        });
-      }
-      return next(app);
-    },
-    async serve(app, next) {
-      if (target_keys.includes(app.build_target)) {
-        const Webview = app.loader.webview();
-        const webview = new Webview(debug);
-        const { host, port } = app.get("http");
-        webview.navigate(`http://${host}:${port}${start}`);
-        webview.run();
-        webview.closed(() => {
-          app.stop();
-        });
-      }
-      return next(app);
-    },
-  };
-};

package/src/platform/darwin-arm64.js

@@ -1 +0,0 @@
-export { default } from "@rcompat/webview/worker/darwin-arm64";

package/src/platform/darwin-x64.js

@@ -1 +0,0 @@
-export { default } from "@rcompat/webview/worker/darwin-x64";

package/src/platform/linux-x64.js

@@ -1 +0,0 @@
-export { default } from "@rcompat/webview/worker/linux-x64";

package/src/platform/windows-x64.js

@@ -1 +0,0 @@
-export { default } from "@rcompat/webview/worker/windows-x64";

package/src/public/loader.js

@@ -1,42 +0,0 @@
-import serve_asset from "primate/serve-asset";
-import file from "@rcompat/fs/file";
-import map from "@rcompat/object/map";
-
-const load = async resource_map =>
-  Object.fromEntries(await Promise.all(Object.entries(resource_map).map(
-    async ([key, url]) => [key, await file(url).text()])));
-
-export default async ({
-  pages_app,
-  page_imports,
-  client_imports,
-  static_imports,
-  static_root,
-  Webview,
-}) => {
-  const clients = map(client_imports, ([key, url]) => [key, file(url)]);
-  const statics = map(static_imports, ([key, url]) => [key, file(url)]);
-  const pages = await load(page_imports);
-
-  return {
-    page(name) {
-      return pages[name] ?? pages[pages_app];
-    },
-    asset(pathname) {
-      const client_file = clients[pathname];
-      if (client_file !== undefined) {
-        return serve_asset(client_file);
-      }
-      if (pathname.startsWith(static_root)) {
-        const assetname = pathname.slice(static_root.length);
-        const static_file = statics[assetname];
-        if (static_file !== undefined) {
-          return serve_asset(static_file);
-        }
-      }
-    },
-    webview() {
-      return Webview;
-    },
-  };
-};

package/src/targets.js

@@ -1,37 +0,0 @@
-import target from "./desktop.js";
-
-const desktop = {
-  forward: `${process.platform}-${process.arch}`,
-};
-
-const linux_x64 = {
-  flags: "--target=bun-linux-x64",
-  exe: "app",
-  target,
-};
-
-const windows_x64 = {
-  flags: "--target=bun-windows-x64",
-  exe: "app.exe",
-  target,
-};
-
-const darwin_x64 = {
-  flags: "--target=bun-darwin-x64",
-  exe: "app",
-  target,
-};
-
-const darwin_arm64 = {
-  flags: "--target=bun-darwin-arm64",
-  exe: "app",
-  target,
-};
-
-export default {
-  desktop,
-  "linux-x64": linux_x64,
-  "windows-x64": windows_x64,
-  "darwin-x64": darwin_x64,
-  "darwin-arm64": darwin_arm64,
-};