primate 0.27.5 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.27.5",
+  "version": "0.28.0",
   "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -9,7 +9,8 @@
     "src/**/*.js",
     "src/errors.json",
     "src/defaults/*.html",
-    "!src/**/*.spec.js"
+    "!src/**/*.spec.js",
+    "types/*.ts"
   ],
   "bin": "src/bin.js",
   "repository": {
@@ -18,11 +19,12 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "rcompat": "^0.5.1"
+    "rcompat": "^0.7.2"
   },
   "engines": {
     "node": ">=18"
   },
   "type": "module",
+  "types": "./types/index.d.ts",
   "exports": "./src/exports.js"
 }

package/src/app.js

@@ -1,6 +1,6 @@
 import crypto from "rcompat/crypto";
 import { tryreturn } from "rcompat/async";
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import { transform, valmap, to } from "rcompat/object";
 import { globify } from "rcompat/string";
@@ -15,8 +15,8 @@ const { DoubleFileExtension } = errors;
 
 // use user-provided file or fall back to default
 const index = (base, page, fallback) =>
-  tryreturn(_ => Path.read(`${base.join(page)}`))
-    .orelse(_ => Path.read(`${base.join(fallback)}`));
+  tryreturn(_ => File.text(`${base.join(page)}`))
+    .orelse(_ => File.text(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
 
@@ -51,7 +51,7 @@ const render_head = (assets, head) =>
         : tags.script({ inline, code, type, integrity, src }),
     ).join("\n").concat("\n", head ?? "");
 
-const { name, version } = await new Path(import.meta.url).up(2)
+const { name, version } = await new File(import.meta.url).up(2)
   .join(runtime.manifest).json();
 
 export default async (log, root, config) => {
@@ -100,7 +100,7 @@ export default async (log, root, config) => {
 
       await Promise.all((await source.collect(filter)).map(async path => {
         const debased = path.debase(this.root).path.slice(1);
-        const filename = new Path(directory).join(path.debase(source));
+        const filename = File.join(directory, path.debase(source));
         const target = await target_base.join(filename.debase(directory));
         await target.directory.create();
         await (regexs.some(regex => regex.test(debased))
@@ -177,7 +177,7 @@ export default async (log, root, config) => {
       }
       if (inline || type === "style") {
         this.assets.push({
-          src: new Path(http.static.root).join(src ?? "").path,
+          src: File.join(http.static.root, src ?? "").path,
           code: inline ? code : "",
           type,
           inline,
@@ -203,7 +203,7 @@ export default async (log, root, config) => {
 
       const parts = module.split("/");
       const path = [this.library, ...parts];
-      const pkg = await Path.resolve().join(...path, this.manifest).json();
+      const pkg = await File.resolve().join(...path, this.manifest).json();
       const exports = pkg.exports === undefined
         ? { [module]: `/${module}/${pkg.main}` }
         : transform(pkg.exports, entry => entry
@@ -220,11 +220,11 @@ export default async (log, root, config) => {
               ?? value.default?.replace(".", `./${module}`)
               ?? value.import?.replace(".", `./${module}`),
           ]));
-      const dependency = Path.resolve().join(...path);
-      const target = new Path(this.runpath(client), this.library, ...parts);
+      const dependency = File.resolve().join(...path);
+      const target = File.join(this.runpath(client), this.library, ...parts);
       await dependency.copy(target);
       this.importmaps = {
-        ...valmap(exports, value => new Path(root, this.library, value).path),
+        ...valmap(exports, value => File.join(root, this.library, value).path),
         ...this.importmaps };
     },
   };

package/src/cwd.js

@@ -1,3 +1,3 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 
-export default (meta, up = 1) => new Path(meta.url).up(up);
+export default (meta, up = 1) => new File(meta.url).up(up);

package/src/errors.js

@@ -1,7 +1,7 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import Logger from "./Logger.js";
 
-const json = await new Path(import.meta.url).up(1).join("errors.json").json();
+const json = await new File(import.meta.url).up(1).join("errors.json").json();
 
 const errors = Logger.err(json.errors, json.module);
 

package/src/hooks/copy_includes.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
   const { config } = app;
@@ -14,7 +14,7 @@ export default async (app, type, post = () => undefined) => {
       .map(async include => {
         const path = app.root.join(include);
         if (await path.exists()) {
-          const target = Path.join(type, include);
+          const target = File.join(type, include);
           await app.stage(path, target);
           await post(target);
         }

package/src/hooks/parse.js

@@ -5,21 +5,17 @@ import errors from "../errors.js";
 
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
-const parse_body = (body, headers, url) =>
-  tryreturn(async _ => {
-    console.log("HHHH");
-    return Body.parse(body, headers.get("content-type")) ?? {};
-  }).orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
+const parse_body = (request, url) =>
+  tryreturn(async _ => await Body.parse(request) ?? {})
+    .orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
 
 export default dispatch => async original => {
   const { headers } = original;
   const url = new URL(deslash(globalThis.decodeURIComponent(original.url)));
   const cookies = headers.get("cookie");
-  const body = await parse_body(original.body, headers, url);
+  const body = await parse_body(original, url);
 
-  return { original, url, body,
-    async_function: async () => "1",
-    ...valmap({
+  return { original, url, body, ...valmap({
     query: [from(url.searchParams), url.search],
     headers: [from(headers), headers, false],
     cookies: [from(cookies?.split(";").map(cookie =>

package/src/hooks/publish.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import { stringify } from "rcompat/object";
 
@@ -7,7 +7,7 @@ const post = async app => {
 
   {
     // after hook, publish a zero assumptions app.js (no css imports)
-    const src = new Path(root, app.config.build.index);
+    const src = File.join(root, app.config.build.index);
 
     await app.publish({
       code: app.exports.filter(({ type }) => type === "script")

package/src/hooks/register.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import cwd from "../cwd.js";
 import copy_includes from "./copy_includes.js";
@@ -17,7 +17,7 @@ const pre = async app => {
   if (await path.components.exists()) {
     // copy .js files from components to build/client/components, since
     // frontend frameworks handle non-js files
-    const target = Path.join(client, components);
+    const target = File.join(client, components);
     await app.stage(path.components, target, /^.*.js$/u);
   }
 
@@ -29,13 +29,13 @@ const post = async app => {
 
   if (await path.static.exists()) {
     // copy static files to build/server/static
-    await app.stage(path.static, new Path(location.server, location.static));
+    await app.stage(path.static, File.join(location.server, location.static));
 
     // copy static files to build/client/static
-    await app.stage(path.static, new Path(location.client, location.static));
+    await app.stage(path.static, File.join(location.client, location.static));
 
     // publish JavaScript and CSS files
-    const imports = await Path.collect(path.static, /\.(?:js|css)$/u);
+    const imports = await File.collect(path.static, /\.(?:js|css)$/u);
     await Promise.all(imports.map(async file => {
       const code = await file.text();
       const src = file.debase(path.static);
@@ -54,7 +54,7 @@ const post = async app => {
   const client = app.runpath(location.client);
   await copy_includes(app, location.client, async to =>
     Promise.all((await to.collect(/\.js$/u)).map(async script => {
-      const src = new Path(root, script.path.replace(client, _ => ""));
+      const src = File.join(root, script.path.replace(client, _ => ""));
       await app.publish({ src, code: await script.text(), type: "module" });
     })),
   );

package/src/hooks/respond/respond.js

@@ -15,10 +15,10 @@ const is_object = value => is_non_null_object(value)
   ? json(value) : is_text(value);
 const is_response = value => is_response_duck(value)
   ? _ => value : is_object(value);
-const isStream = value => value instanceof ReadableStream
+const is_stream = value => value instanceof ReadableStream
   ? stream(value) : is_response(value);
 const is_blob = value => value instanceof Blob
-  ? stream(value) : isStream(value);
+ ? stream(value.stream()) : is_stream(value);
 const is_URL = value => value instanceof URL
   ? redirect(value.href) : is_blob(value);
 const guess = value => is_URL(value);

package/src/loaders/common.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { identity } from "rcompat/function";
 import errors from "../errors.js";
 
@@ -17,13 +17,13 @@ export default async ({
   warn = true,
 } = {}) => {
   const objects = directory === undefined ? [] : await Promise.all(
-    (await Path.collect(directory, /^.*.js$/u, { recursive }))
+    (await File.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
       .map(async path => [
         `${path}`.replace(directory, _ => "").slice(1, -ending.length),
-        (await import(path)),
+        await import(path),
       ]));
-  warn && await Path.exists(directory) && empty(log)(objects, name, directory);
+  warn && await directory.exists() && empty(log)(objects, name, directory);
 
   return objects;
 };

package/src/loaders/routes/load.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import errors from "../../errors.js";
 import to_sorted from "../../to_sorted.js";
 
@@ -10,7 +10,7 @@ export default type => async (log, directory, load) => {
     .map(([name, object]) => [name.replace(replace, () => ""), object]),
   ([a], [b]) => a.length - b.length);
 
-  const resolve = name => new Path(directory, name, `+${type}.js`);
+  const resolve = name => File.join(directory, name, `+${type}.js`);
   objects.some(([name, value]) => typeof value.default !== "function"
     && errors.InvalidDefaultExport.throw(resolve(name)));
 

package/src/loaders/types.js

@@ -1,4 +1,4 @@
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
@@ -10,7 +10,7 @@ export default async (log, directory, load = fs) => {
   const types = (await load({ log, directory, name: "types", filter }))
     .map(([name, type]) => [name, type.default]);
 
-  const resolve = name => new Path(directory, name);
+  const resolve = name => File.join(directory, name);
   types.every(([name, type]) => tryreturn(_ => {
     is(type).object();
     is(type.base).string();

package/src/run.js

@@ -1,5 +1,5 @@
 import { tryreturn } from "rcompat/async";
-import { Path } from "rcompat/fs";
+import { File } from "rcompat/fs";
 import { extend } from "rcompat/object";
 import app from "./app.js";
 import { default as Logger, bye } from "./Logger.js";
@@ -28,7 +28,7 @@ const get_config = async root => {
 
 export default async name => tryreturn(async _ => {
   // use module root if possible, fall back to current directory
-  const root = await tryreturn(_ => Path.root()).orelse(_ => Path.resolve());
+  const root = await tryreturn(_ => File.root()).orelse(_ => File.resolve());
   const config = await get_config(root);
   logger = new Logger(config.logger);
   await command(name)(await app(logger, root, config));

package/types/index.d.ts

@@ -0,0 +1,64 @@
+declare module "primate" {
+  type App = any;
+
+  interface MinOptions {
+    status: number,
+  }
+  
+  interface ErrorOptions extends MinOptions {
+    page: string,
+  }
+
+  interface Options extends ErrorOptions {
+    placeholders: {},
+    headers: Headers | {},
+  }
+
+  type Dispatcher = {
+    get(property: string): string,
+  };
+
+  type RequestFacade = {
+    body: {}
+    path: Dispatcher,
+    query: Dispatcher,
+    cookies: Dispatcher,
+    headers: Dispatcher,
+    original: Request,
+  };
+
+  type ResponseFn = (app: App, ...rest: any) => Response;
+  type ResponseFacade = 
+    string 
+  | object
+  | URL
+  | Blob
+  | ReadableStream
+  | Response
+  | ResponseFn;
+
+  type RouteFunction = (request?: RequestFacade) => ResponseFacade;
+
+  type Streamable = ReadableStream | Blob;
+
+  export type Route = {
+    get?: RouteFunction,
+    post?: RouteFunction,
+    put?: RouteFunction,
+    delete?: RouteFunction,
+  };
+
+  export function text(body: string, options?: MinOptions): ResponseFn;
+
+  export function json(body: {}, options?: MinOptions): ResponseFn;
+
+  export function stream(body: Streamable, options?: MinOptions): ResponseFn;
+
+  export function redirect(location: string, options?: MinOptions): ResponseFn;
+
+  export function html(name: string, options?: MinOptions): ResponseFn;
+
+  export function view(name: string, props: {}, options?: Options): ResponseFn;
+
+  export function error(body: string, options?: ErrorOptions): ResponseFn;
+}