primate 0.29.3 → 0.29.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",

package/src/app.js

@@ -80,7 +80,7 @@ export default async (log, root, config) => {
     root,
     log,
     error: {
-      default: await error.exists() ? (await import(error)).default : undefined,
+      default: await error.exists() ? await error.import("default") : undefined,
     },
     handlers: { ...handlers },
     extensions: {

package/src/hooks/respond/respond.js

@@ -1,26 +1,30 @@
-import { Blob } from "rcompat/fs";
-import { URL } from "rcompat/http";
+import { Blob, s_streamable } from "rcompat/fs";
+import { URL, Response } from "rcompat/http";
+import { identity } from "rcompat/function";
 import { text, json, stream, redirect } from "primate";
-import is_response_duck from "./duck.js";
 
-const is_text = value => {
-  if (typeof value === "string") {
-    return text(value);
-  }
+const not_found = value => {
   throw new Error(`no handler found for ${value}`);
 };
-
+const is_text = value => typeof value === "string";
 const is_non_null_object = value => typeof value === "object" && value !== null;
-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 is_stream = value => value instanceof ReadableStream
-  ? stream(value) : is_response(value);
-const is_blob = value => value instanceof Blob
-  ? 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);
+const is_instance = of => value => value instanceof of;
+const is_response = is_instance(Response);
+const is_global_response = is_instance(globalThis.Response);
+const is_streamable =
+  value => value instanceof Blob || value?.streamable === s_streamable;
+
+// [if, then]
+const guesses = [
+  [is_instance(URL), redirect],
+  [is_streamable, value => stream(value.stream())],
+  [is_instance(ReadableStream), stream],
+  [value => is_response(value) || is_global_response(value), identity],
+  [is_non_null_object, json],
+  [is_text, text],
+  [not_found, identity],
+];
+
+const guess = value => guesses.find(([check]) => check(value))?.[1](value);
 
 export default result => typeof result === "function" ? result : guess(result);

package/src/loaders/common.js

@@ -19,9 +19,9 @@ export default async ({
   const objects = directory === undefined ? [] : await Promise.all(
     (await File.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
-      .map(async path => [
-        `${path}`.replace(directory, _ => "").slice(1, -ending.length),
-        await import(path),
+      .map(async file => [
+        `${file}`.replace(directory, _ => "").slice(1, -ending.length),
+        await file.import(),
       ]));
   warn && await directory.exists() && empty(log)(objects, name, directory);
 

package/src/run.js

@@ -15,7 +15,7 @@ const get_config = async root => {
   const config = root.join(name);
   return await config.exists()
     ? tryreturn(async _ => {
-      const imported = (await import(config)).default;
+      const imported = await config.import("default");
 
       (imported === undefined || Object.keys(imported).length === 0) &&
         errors.EmptyConfigFile.warn(logger, config);

package/types/index.d.ts

@@ -1,30 +1,69 @@
-declare module 'primate' {
-	function _default(command: any): Promise<any>;
-	export default _default;
-	export function text(body: any, options: any): (app: any) => any;
-	export function json(body: any, options: any): (app: any) => any;
-	export function stream(body: any, options: any): (app: any) => any;
-	export function redirect(Location: any, { status }?: {
-		status?: any;
-	}): (app: any) => any;
-	export function error(body?: string, { status, page }?: {
-		status?: any;
-		page: any;
-	}): (app: any) => any;
-	export function html(name: any, options: any): (app: any) => Promise<any>;
-	/**
-	 * Render a component using handler for the given filename extension.
-	 * @param name component filename
-	 * @param props props passed to component
-	 * @param options rendering options
-	 */
-	export function view(name: string, props: object, options: object): (app: any, ...rest: any[]) => Promise<any>;
-	export function ws(implementation: any): ({ server }: {
-		server: any;
-	}, _: any, { original }: {
-		original: any;
-	}) => any;
-	export function sse(body: any, options: any): (app: any) => any;
-}
+declare module "primate" {
+  type App = any;
+
+  interface MinOptions {
+    status: number,
+    headers: Headers | {},
+  }
+  
+  interface ErrorOptions extends MinOptions {
+    page: string,
+  }
+
+  interface Options extends ErrorOptions {
+    placeholders: {},
+  }
+
+  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,
+  };
 
-//# sourceMappingURL=index.d.ts.map
+  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;
+
+  export function sse(implementation: {
+    open?: () => void,
+    close?: () => void,
+  }, options?: MinOptions): ResponseFn;
+}