@riddance/host 0.0.12 → 0.0.13

package/host/registry.d.ts

@@ -1,26 +1,27 @@
-import { HandlerConfiguration } from '../context.js';
-import { Handler } from '../http.js';
-export type HttpHandler = {
-    meta: Metadata | undefined;
-    config: (PackageConfiguration & HandlerConfiguration) | undefined;
-    method: Method;
-    pathPattern: string;
-    pathRegExp: RegExp;
-    entry: Handler;
-};
-type HandlerTypes = {
-    http: HttpHandler;
-};
-export declare function getHandlers(type: keyof HandlerTypes): HttpHandler[];
-export declare function getHandler(type: keyof HandlerTypes): HttpHandler;
-export declare function setMeta(packageName: string, fileName: string, revision: string | undefined, config: PackageConfiguration | undefined): void;
-export type PackageConfiguration = HandlerConfiguration & {};
-export type Metadata = {
-    packageName: string;
-    fileName: string;
-    revision: string | undefined;
-    config?: PackageConfiguration;
-};
-export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-export declare function registerHttpHandler(method: Method, path: string, configOrHandler: HandlerConfiguration | Handler, fn?: Handler): void;
-export {};
+import { HandlerConfiguration } from '../context.js';
+import { Handler } from '../http.js';
+export type HttpHandler = {
+    meta: Metadata | undefined;
+    config: FullConfiguration | undefined;
+    method: Method;
+    pathPattern: string;
+    pathRegExp: RegExp;
+    entry: Handler;
+};
+type HandlerTypes = {
+    http: HttpHandler;
+};
+export declare function getHandlers(type: keyof HandlerTypes): HttpHandler[];
+export declare function getHandler(type: keyof HandlerTypes): HttpHandler;
+export declare function setMeta(packageName: string, fileName: string, revision: string | undefined, config: PackageConfiguration | undefined): void;
+export type PackageConfiguration = HandlerConfiguration & {};
+export type FullConfiguration = PackageConfiguration & HandlerConfiguration;
+export type Metadata = {
+    packageName: string;
+    fileName: string;
+    revision: string | undefined;
+    config?: PackageConfiguration;
+};
+export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export declare function registerHttpHandler(method: Method, path: string, configOrHandler: HandlerConfiguration | Handler, fn?: Handler): void;
+export {};

package/host/registry.js

@@ -1,72 +1,73 @@
-const handlers = {};
-function addHandler(type, handler) {
-    ;
-    (handlers[type] ??= []).push(handler);
-}
-export function getHandlers(type) {
-    return (handlers[type] ?? []);
-}
-export function getHandler(type) {
-    const hs = getHandlers(type);
-    const [handler] = hs;
-    if (!handler) {
-        throw new Error(`No ${type} handler registered.`);
-    }
-    if (hs.length !== 1) {
-        throw new Error(`Multiple ${type} handlers registered.`);
-    }
-    return handler;
-}
-let httpHostRegistry;
-function setHttpHost(host) {
-    httpHostRegistry = host;
-}
-let metadata;
-export function setMeta(packageName, fileName, revision, config) {
-    metadata = {
-        packageName,
-        fileName,
-        revision,
-        config,
-    };
-}
-function getMetadata() {
-    return metadata;
-}
-function pathToRegExp(path) {
-    return new RegExp(('^' +
-        path.replace(/[/\\^$+?.()|[\]{}]/gu, '\\$&').replaceAll('*', '[^/\\?]+') +
-        '(\\?.*)?$').replace('[^/\\?]+[^/\\?]+(\\?.*)?$', ''), 'u');
-}
-function combineConfig(base, override) {
-    if (base === undefined) {
-        return override;
-    }
-    else if (override === undefined) {
-        return base;
-    }
-    return { ...base, ...override };
-}
-function httpHost(meta, cfg, method, path, entry) {
-    addHandler('http', {
-        meta,
-        config: combineConfig(meta?.config, cfg),
-        method,
-        pathPattern: path,
-        pathRegExp: pathToRegExp(path),
-        entry,
-    });
-}
-setHttpHost(httpHost);
-export function registerHttpHandler(method, path, configOrHandler, fn) {
-    if (typeof configOrHandler === 'function') {
-        httpHostRegistry(getMetadata(), undefined, method, path, configOrHandler);
-    }
-    else {
-        if (!fn) {
-            throw new Error('Please provide a handler function.');
-        }
-        httpHostRegistry(getMetadata(), configOrHandler, method, path, fn);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+const handlers = {};
+function addHandler(type, handler) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    ;
+    (handlers[type] ??= []).push(handler);
+}
+export function getHandlers(type) {
+    return (handlers[type] ?? []);
+}
+export function getHandler(type) {
+    const hs = getHandlers(type);
+    const [handler] = hs;
+    if (!handler) {
+        throw new Error(`No ${type} handler registered.`);
+    }
+    if (hs.length !== 1) {
+        throw new Error(`Multiple ${type} handlers registered.`);
+    }
+    return handler;
+}
+let httpHostRegistry;
+function setHttpHost(host) {
+    httpHostRegistry = host;
+}
+let metadata;
+export function setMeta(packageName, fileName, revision, config) {
+    metadata = {
+        packageName,
+        fileName,
+        revision,
+        config,
+    };
+}
+function getMetadata() {
+    return metadata;
+}
+function pathToRegExp(path) {
+    return new RegExp(('^' +
+        path.replace(/[/\\^$+?.()|[\]{}]/gu, '\\$&').replaceAll('*', '[^/\\?]+') +
+        '(\\?.*)?$').replace('[^/\\?]+[^/\\?]+(\\?.*)?$', ''), 'u');
+}
+function combineConfig(base, override) {
+    if (base === undefined) {
+        return override;
+    }
+    else if (override === undefined) {
+        return base;
+    }
+    return { ...base, ...override };
+}
+function httpHost(meta, cfg, method, path, entry) {
+    addHandler('http', {
+        meta,
+        config: combineConfig(meta?.config, cfg),
+        method,
+        pathPattern: path,
+        pathRegExp: pathToRegExp(path),
+        entry,
+    });
+}
+setHttpHost(httpHost);
+export function registerHttpHandler(method, path, configOrHandler, fn) {
+    if (typeof configOrHandler === 'function') {
+        httpHostRegistry(getMetadata(), undefined, method, path, configOrHandler);
+    }
+    else {
+        if (!fn) {
+            throw new Error('Please provide a handler function.');
+        }
+        httpHostRegistry(getMetadata(), configOrHandler, method, path, fn);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["registry.ts"],"names":[],"mappings":"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","sourcesContent":["import { HandlerConfiguration } from '../context.js'\nimport { Handler } from '../http.js'\n\nexport type HttpHandler = {\n    meta: Metadata | undefined\n    // eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents\n    config: FullConfiguration | undefined\n    method: Method\n    pathPattern: string\n    pathRegExp: RegExp\n    entry: Handler\n}\n\ntype HandlerTypes = {\n    http: HttpHandler\n}\n\nconst handlers: { [key: string]: unknown[] } = {}\n\nfunction addHandler(type: keyof HandlerTypes, handler: HttpHandler) {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    ;(handlers[type] ??= []).push(handler)\n}\n\nexport function getHandlers(type: keyof HandlerTypes) {\n    return (handlers[type] ?? []) as HttpHandler[]\n}\n\nexport function getHandler(type: keyof HandlerTypes) {\n    const hs = getHandlers(type)\n    const [handler] = hs\n    if (!handler) {\n        throw new Error(`No ${type} handler registered.`)\n    }\n    if (hs.length !== 1) {\n        throw new Error(`Multiple ${type} handlers registered.`)\n    }\n    return handler\n}\n\ntype HttpHost = (\n    meta: Metadata | undefined,\n    config: HandlerConfiguration | undefined,\n    method: Method,\n    path: string,\n    handler: Handler,\n) => void\n\nlet httpHostRegistry: HttpHost\n\nfunction setHttpHost(host: HttpHost) {\n    httpHostRegistry = host\n}\n\nlet metadata: Metadata | undefined\n\nexport function setMeta(\n    packageName: string,\n    fileName: string,\n    revision: string | undefined,\n    config: PackageConfiguration | undefined,\n) {\n    metadata = {\n        packageName,\n        fileName,\n        revision,\n        config,\n    }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport type PackageConfiguration = HandlerConfiguration & {\n    // Placeholder for package-level configurations\n}\n\n// eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents\nexport type FullConfiguration = PackageConfiguration & HandlerConfiguration\n\nexport type Metadata = {\n    packageName: string\n    fileName: string\n    revision: string | undefined\n    config?: PackageConfiguration\n}\n\nfunction getMetadata() {\n    return metadata\n}\n\nfunction pathToRegExp(path: string) {\n    return new RegExp(\n        (\n            '^' +\n            path.replace(/[/\\\\^$+?.()|[\\]{}]/gu, '\\\\$&').replaceAll('*', '[^/\\\\?]+') +\n            '(\\\\?.*)?$'\n        ).replace('[^/\\\\?]+[^/\\\\?]+(\\\\?.*)?$', ''),\n        'u',\n    )\n}\n\nfunction combineConfig(\n    base: PackageConfiguration | undefined,\n    override: HandlerConfiguration | undefined,\n    // eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents\n): FullConfiguration | undefined {\n    if (base === undefined) {\n        return override\n    } else if (override === undefined) {\n        return base\n    }\n    return { ...base, ...override }\n}\n\nfunction httpHost(\n    meta: Metadata | undefined,\n    cfg: HandlerConfiguration | undefined,\n    method: Method,\n    path: string,\n    entry: Handler,\n) {\n    addHandler('http', {\n        meta,\n        config: combineConfig(meta?.config, cfg),\n        method,\n        pathPattern: path,\n        pathRegExp: pathToRegExp(path),\n        entry,\n    })\n}\n\nsetHttpHost(httpHost)\n\nexport type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'\n\nexport function registerHttpHandler(\n    method: Method,\n    path: string,\n    configOrHandler: HandlerConfiguration | Handler,\n    fn?: Handler,\n): void {\n    if (typeof configOrHandler === 'function') {\n        httpHostRegistry(getMetadata(), undefined, method, path, configOrHandler)\n    } else {\n        if (!fn) {\n            throw new Error('Please provide a handler function.')\n        }\n        httpHostRegistry(getMetadata(), configOrHandler, method, path, fn)\n    }\n}\n"]}

package/http.d.ts

@@ -1,39 +1,39 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { UrlWithParsedQuery } from 'node:url';
-import { Context, HandlerConfiguration, Json } from './context.js';
-export * from './context.js';
-export type ResponseHeaders = {
-    [key: string]: string;
-};
-export type FullResult = {
-    headers?: ResponseHeaders;
-    status?: number;
-    body?: unknown;
-};
-export type Result = void | string | FullResult;
-export type HttpRequest = {
-    readonly rawUrl: string;
-    readonly url: Readonly<UrlWithParsedQuery> & {
-        pathStepAt: (index: number) => string;
-    };
-    readonly headers: Readonly<ResponseHeaders>;
-    readonly body?: Json | string;
-};
-export type HttpHandlerConfiguration = HandlerConfiguration & {
-    /**
-     * A string identifying which domains can access the endpoint cross-origin.
-     * @default undefined
-     */
-    readonly cors?: string;
-};
-export type Handler = (context: Context, request: HttpRequest) => Promise<Result> | Result;
-export declare function get(path: string, fn: Handler): void;
-export declare function get(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
-export declare function post(path: string, fn: Handler): void;
-export declare function post(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
-export declare function put(path: string, fn: Handler): void;
-export declare function put(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
-export declare function patch(path: string, fn: Handler): void;
-export declare function patch(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
-export declare function del(path: string, fn: Handler): void;
-export declare function del(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+/// <reference types="node" resolution-mode="require"/>
+import type { UrlWithParsedQuery } from 'node:url';
+import { Context, HandlerConfiguration, Json } from './context.js';
+export * from './context.js';
+export type ResponseHeaders = {
+    [key: string]: string;
+};
+export type FullResult = {
+    headers?: ResponseHeaders;
+    status?: number;
+    body?: unknown;
+};
+export type Result = void | string | FullResult;
+export type HttpRequest = {
+    readonly rawUrl: string;
+    readonly url: Readonly<UrlWithParsedQuery> & {
+        pathStepAt: (index: number) => string;
+    };
+    readonly headers: Readonly<ResponseHeaders>;
+    readonly body?: Json | string;
+};
+export type HttpHandlerConfiguration = HandlerConfiguration & {
+    /**
+     * A string identifying which domains can access the endpoint cross-origin.
+     * @default undefined
+     */
+    readonly cors?: string;
+};
+export type Handler = (context: Context, request: HttpRequest) => Promise<Result> | Result;
+export declare function get(path: string, fn: Handler): void;
+export declare function get(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function post(path: string, fn: Handler): void;
+export declare function post(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function put(path: string, fn: Handler): void;
+export declare function put(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function patch(path: string, fn: Handler): void;
+export declare function patch(path: string, config: HttpHandlerConfiguration, fn: Handler): void;
+export declare function del(path: string, fn: Handler): void;
+export declare function del(path: string, config: HttpHandlerConfiguration, fn: Handler): void;

package/http.js

@@ -1,18 +1,18 @@
-import { registerHttpHandler } from './host/registry.js';
-export * from './context.js';
-export function get(path, configOrHandler, fn) {
-    registerHttpHandler('GET', path, configOrHandler, fn);
-}
-export function post(path, configOrHandler, fn) {
-    registerHttpHandler('POST', path, configOrHandler, fn);
-}
-export function put(path, configOrHandler, fn) {
-    registerHttpHandler('PUT', path, configOrHandler, fn);
-}
-export function patch(path, configOrHandler, fn) {
-    registerHttpHandler('PATCH', path, configOrHandler, fn);
-}
-export function del(path, configOrHandler, fn) {
-    registerHttpHandler('DELETE', path, configOrHandler, fn);
-}
+import { registerHttpHandler } from './host/registry.js';
+export * from './context.js';
+export function get(path, configOrHandler, fn) {
+    registerHttpHandler('GET', path, configOrHandler, fn);
+}
+export function post(path, configOrHandler, fn) {
+    registerHttpHandler('POST', path, configOrHandler, fn);
+}
+export function put(path, configOrHandler, fn) {
+    registerHttpHandler('PUT', path, configOrHandler, fn);
+}
+export function patch(path, configOrHandler, fn) {
+    registerHttpHandler('PATCH', path, configOrHandler, fn);
+}
+export function del(path, configOrHandler, fn) {
+    registerHttpHandler('DELETE', path, configOrHandler, fn);
+}
 //# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@riddance/host",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "license": "MIT",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "keywords": [
     "riddance",
@@ -29,10 +29,13 @@
     "./http": "./host/http.js"
   },
   "scripts": {
+    "start": "riddance-watch",
     "prepack": "riddance-build",
-    "start": "riddance-watch"
+    "prepublishOnly": "riddance-prepublish",
+    "postpublish": "riddance-sync"
   },
   "devDependencies": {
-    "@riddance/env": "0.2.6"
-  }
-}
+    "@riddance/env": "0.4.3"
+  },
+  "gitHead": "8f6355e2dd0a0881e596de90c2898c64107e1c7b"
+}