@rest-vir/define-service 0.0.2

package/dist/util/path-to-regexp.js

@@ -0,0 +1,307 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+// cspell:ignore Embrey
+/* node:coverage disable */
+/**
+ * This file was copied from
+ * https://github.com/pillarjs/path-to-regexp/blob/39e861d02d959ba99d0632af994ab48d4a8eeb14/src/index.ts
+ * because its published package on Npm is not browser friendly. It has been modified here to remove
+ * all code not used in rest-vir and to meet rest-vir's coding standards.
+ *
+ * The original package and file source have the following license:
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const DEFAULT_DELIMITER = '/';
+const ID_START = /^[$_\p{ID_Start}]$/u;
+const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+const DEBUG_URL = 'https://git.new/pathToRegexpError';
+const SIMPLE_TOKENS = {
+    // Groups.
+    '{': '{',
+    '}': '}',
+    // Reserved.
+    '(': '(',
+    ')': ')',
+    '[': '[',
+    ']': ']',
+    '+': '+',
+    '?': '?',
+    '!': '!',
+};
+/** Escape a regular expression string. */
+function escape(str) {
+    return str.replace(/[.+*?^${}()[\]|/\\]/g, String.raw `\$&`);
+}
+/** Tokenize input string. */
+function* lexer(str) {
+    const chars = str.split('');
+    let i = 0;
+    function name() {
+        let value = '';
+        if (ID_START.test(chars[++i])) {
+            value += chars[i];
+            while (ID_CONTINUE.test(chars[++i])) {
+                value += chars[i];
+            }
+        }
+        else if (chars[i] === '"') {
+            let pos = i;
+            while (i < chars.length) {
+                if (chars[++i] === '"') {
+                    i++;
+                    pos = 0;
+                    break;
+                }
+                if (chars[i] === '\\') {
+                    value += chars[++i];
+                }
+                else {
+                    value += chars[i];
+                }
+            }
+            if (pos) {
+                throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+            }
+        }
+        if (!value) {
+            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+        }
+        return value;
+    }
+    while (i < chars.length) {
+        const value = chars[i];
+        const type = SIMPLE_TOKENS[value];
+        if (type) {
+            yield { type, index: i++, value };
+        }
+        else if (value === '\\') {
+            yield { type: 'ESCAPED', index: i++, value: chars[i++] };
+        }
+        else if (value === ':') {
+            const value = name();
+            yield { type: 'PARAM', index: i, value };
+        }
+        else if (value === '*') {
+            const value = name();
+            yield { type: 'WILDCARD', index: i, value };
+        }
+        else {
+            yield { type: 'CHAR', index: i, value: chars[i++] };
+        }
+    }
+    return { type: 'END', index: i, value: '' };
+}
+class Iter {
+    tokens;
+    _peek;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    peek() {
+        if (!this._peek) {
+            const next = this.tokens.next();
+            this._peek = next.value;
+        }
+        return this._peek;
+    }
+    tryConsume(type) {
+        const token = this.peek();
+        if (token.type !== type) {
+            return;
+        }
+        this._peek = undefined; // Reset after consumed.
+        return token.value;
+    }
+    consume(type) {
+        const value = this.tryConsume(type);
+        if (value !== undefined) {
+            return value;
+        }
+        const { type: nextType, index } = this.peek();
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
+    }
+    text() {
+        let result = '';
+        let value;
+        while ((value = this.tryConsume('CHAR') || this.tryConsume('ESCAPED'))) {
+            result += value;
+        }
+        return result;
+    }
+}
+/** Tokenized path instance. */
+class TokenData {
+    tokens;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+}
+/** Parse a string for the raw tokens. */
+function parse(stringToParse) {
+    const iterator = new Iter(lexer(stringToParse));
+    function consume(endType) {
+        const tokens = [];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        while (true) {
+            const path = iterator.text();
+            if (path) {
+                tokens.push({ type: 'text', value: path });
+            }
+            const param = iterator.tryConsume('PARAM');
+            if (param) {
+                tokens.push({
+                    type: 'param',
+                    name: param,
+                });
+                continue;
+            }
+            const wildcard = iterator.tryConsume('WILDCARD');
+            if (wildcard) {
+                tokens.push({
+                    type: 'wildcard',
+                    name: wildcard,
+                });
+                continue;
+            }
+            const open = iterator.tryConsume('{');
+            if (open) {
+                tokens.push({
+                    type: 'group',
+                    tokens: consume('}'),
+                });
+                continue;
+            }
+            iterator.consume(endType);
+            return tokens;
+        }
+    }
+    const tokens = consume('END');
+    return new TokenData(tokens);
+}
+/**
+ * Transform a path into a match function.
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function match(path) {
+    const { regexp, keys } = pathToRegexp(path);
+    const decoders = keys.map((key) => {
+        if (key.type === 'param') {
+            return decodeURIComponent;
+        }
+        return (value) => value.split(DEFAULT_DELIMITER).map(decodeURIComponent);
+    });
+    return function match(input) {
+        const m = regexp.exec(input);
+        if (!m) {
+            return false;
+        }
+        const path = m[0];
+        const params = Object.create(null);
+        for (let i = 1; i < m.length; i++) {
+            if (m[i] === undefined) {
+                continue;
+            }
+            const key = keys[i - 1];
+            const decoder = decoders[i - 1];
+            params[key.name] = decoder(m[i]);
+        }
+        return { path, params };
+    };
+}
+function pathToRegexp(path) {
+    const keys = [];
+    const sources = [];
+    const flags = 'i';
+    for (const seq of flat(path)) {
+        sources.push(toRegExp(seq, keys));
+    }
+    let pattern = `^(?:${sources.join('|')})`;
+    pattern += `(?:${escape(DEFAULT_DELIMITER)}$)?`;
+    pattern += '$';
+    const regexp = new RegExp(pattern, flags);
+    return { regexp, keys };
+}
+/** Path or array of paths to normalize. */
+function* flat(path) {
+    const data = parse(path);
+    yield* flatten(data.tokens, 0, []);
+}
+/** Generate a flat list of sequence tokens from the given tokens. */
+function* flatten(tokens, index, init) {
+    if (index === tokens.length) {
+        return yield init;
+    }
+    const token = tokens[index];
+    if (token.type === 'group') {
+        for (const seq of flatten(token.tokens, 0, init.slice())) {
+            yield* flatten(tokens, index + 1, seq);
+        }
+    }
+    else {
+        init.push(token);
+    }
+    yield* flatten(tokens, index + 1, init);
+}
+/** Transform a flat sequence of tokens into a regular expression. */
+function toRegExp(tokens, keys) {
+    let result = '';
+    let backtrack = '';
+    let isSafeSegmentParam = true;
+    for (const token of tokens) {
+        if (token.type === 'text') {
+            result += escape(token.value);
+            backtrack += token.value;
+            isSafeSegmentParam ||= token.value.includes(DEFAULT_DELIMITER);
+        }
+        else {
+            if (!isSafeSegmentParam && !backtrack) {
+                throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+            }
+            if (token.type === 'param') {
+                result += `(${negate(DEFAULT_DELIMITER, isSafeSegmentParam ? '' : backtrack)}+)`;
+            }
+            else {
+                result += `([\\s\\S]+)`;
+            }
+            keys.push(token);
+            backtrack = '';
+            isSafeSegmentParam = false;
+        }
+    }
+    return result;
+}
+/** Block backtracking on previous text and ignore delimiter string. */
+function negate(delimiter, backtrack) {
+    if (backtrack.length < 2) {
+        if (delimiter.length < 2) {
+            return `[^${escape(delimiter + backtrack)}]`;
+        }
+        return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
+    }
+    if (delimiter.length < 2) {
+        return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
+    }
+    return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
+}

package/dist/util/search-params.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The base, generic type for a parsed search params object, extracted from a request URL. If there
+ * are no search params, this will be an empty object.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type BaseSearchParams = Record<string, string[]>;

package/dist/util/search-params.js

@@ -0,0 +1 @@
+export {};

package/dist/web-socket/common-web-socket.d.ts

@@ -0,0 +1,103 @@
+import type { AnyFunction } from '@augment-vir/common';
+/**
+ * A WebSocket interface that matches both [client-side
+ * WebSockets](https://developer.mozilla.org/docs/Web/API/WebSocket) and [host-side
+ * WebSockets](https://github.com/websockets/ws/blob/HEAD/doc/ws.md#class-websocket).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare abstract class CommonWebSocket {
+    constructor(url: string | URL, protocols?: string | string[]);
+    /**
+     * A `WebSocket.send` method that is compatible with the native method
+     * (https://developer.mozilla.org/docs/Web/API/WebSocket/send) and the `ws` package's method
+     * (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketsenddata-options-callback)
+     */
+    abstract send: (data: any) => void;
+    /**
+     * A `WebSocket.readyState` property that is compatible with the native property
+     * (https://developer.mozilla.org/docs/Web/API/WebSocket/readyState) and the `ws` package's
+     * property (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketreadystate)
+     */
+    abstract readyState: CommonWebSocketState;
+    /**
+     * A `WebSocket.addEventListener` method that is compatible with the native method
+     * (https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener) and the `ws`
+     * package's method
+     * (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketaddeventlistenertype-listener-options)
+     */
+    abstract addEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: (event: CommonWebSocketEventMap[EventName]) => void, options?: CommonWebSocketListenerOptions): void;
+    /**
+     * A `WebSocket.removeEventListener` method that is compatible with the native method
+     * (https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener) and the `ws`
+     * package's method
+     * (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketremoveeventlistenertype-listener)
+     */
+    abstract removeEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: AnyFunction): void;
+    /**
+     * A `WebSocket.close` method that is compatible with the native method
+     * (https://developer.mozilla.org/docs/Web/API/WebSocket/close) and the `ws` package's method
+     * (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketclosecode-reason)
+     */
+    abstract close(): void;
+}
+/**
+ * `WebSocket.addEventListener` options that are compatible with both the native method
+ * (https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener) and the `ws` package's
+ * method
+ * (https://github.com/websockets/ws/blob/HEAD/doc/ws.md#websocketaddeventlistenertype-listener-options)
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type CommonWebSocketListenerOptions = {
+    once?: boolean;
+};
+/**
+ * All values for
+ * [WebSocket.readyState](https://developer.mozilla.org/docs/Web/API/WebSocket/readyState).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare enum CommonWebSocketState {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3
+}
+/**
+ * A mapping of WebSocket events that are compatible with both [client-side
+ * WebSockets](https://developer.mozilla.org/docs/Web/API/WebSocket) and [host-side
+ * WebSockets](https://github.com/websockets/ws/blob/HEAD/doc/ws.md#class-websocket).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type CommonWebSocketEventMap = {
+    open: {
+        target: CommonWebSocket;
+        type: string;
+    };
+    error: {
+        target: CommonWebSocket;
+        type: string;
+    };
+    close: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+        target: CommonWebSocket;
+        type: string;
+    };
+    message: {
+        data: unknown;
+        target: CommonWebSocket;
+        type: string;
+    };
+};

package/dist/web-socket/common-web-socket.js

@@ -0,0 +1,28 @@
+/**
+ * A WebSocket interface that matches both [client-side
+ * WebSockets](https://developer.mozilla.org/docs/Web/API/WebSocket) and [host-side
+ * WebSockets](https://github.com/websockets/ws/blob/HEAD/doc/ws.md#class-websocket).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export class CommonWebSocket {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(url, protocols) { }
+}
+/**
+ * All values for
+ * [WebSocket.readyState](https://developer.mozilla.org/docs/Web/API/WebSocket/readyState).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export var CommonWebSocketState;
+(function (CommonWebSocketState) {
+    CommonWebSocketState[CommonWebSocketState["Connecting"] = 0] = "Connecting";
+    CommonWebSocketState[CommonWebSocketState["Open"] = 1] = "Open";
+    CommonWebSocketState[CommonWebSocketState["Closing"] = 2] = "Closing";
+    CommonWebSocketState[CommonWebSocketState["Closed"] = 3] = "Closed";
+})(CommonWebSocketState || (CommonWebSocketState = {}));