@mpen/rerouter 0.1.9 → 0.3.0

package/dist/bundle.mjs

@@ -1,420 +0,0 @@
-const PREFIX_RE = /^[+#./;?&]/;
-
-const MODIFIER_RE = /(?<repeat>\*)?(?::(?<func>[a-zA-Z][a-zA-Z0-9_]*))?(?::(?:(?<length>\d+)))?$/;
-
-const UNRESERVED = /[^a-zA-Z0-9\-._~]+/gsu;
-
-const UR_SET = /[^a-zA-Z0-9\-._~:\/?#[\]@!$&'()*+,;=]+/gsu;
-
-const PERCENT_RE = /^%[0-9a-fA-F]{2}$/;
-
-const STR = Symbol("string");
-
-const VAR = Symbol("var");
-
-const SeparatorMap = {
-    "": ",",
-    "+": ",",
-    ".": ".",
-    "/": "/",
-    ";": ";",
-    "?": "&",
-    "&": "&",
-    "#": ","
-};
-
-const FirstMap = {
-    "": "",
-    "+": "",
-    ".": ".",
-    "/": "/",
-    ";": ";",
-    "?": "?",
-    "&": "&",
-    "#": "#"
-};
-
-const Named = {
-    "": false,
-    "+": false,
-    ".": false,
-    "/": false,
-    ";": true,
-    "?": true,
-    "&": true,
-    "#": false
-};
-
-const IfEmp = {
-    "": "",
-    "+": "",
-    ".": "",
-    "/": "",
-    ";": "",
-    "?": "=",
-    "&": "=",
-    "#": ""
-};
-
-const ReservedExpansion = {
-    "": false,
-    "+": true,
-    ".": false,
-    "/": false,
-    ";": false,
-    "?": false,
-    "&": false,
-    "#": true
-};
-
-var VarType;
-
-(function(VarType) {
-    VarType[VarType["NAMED"] = 0] = "NAMED";
-    VarType[VarType["STATIC"] = 1] = "STATIC";
-    VarType[VarType["DYNAMIC"] = 2] = "DYNAMIC";
-})(VarType || (VarType = {}));
-
-class UriTemplate {
-    expandParts;
-    matchRegex;
-    matchMap;
-    constructor(template) {
-        this.expandParts = [];
-        const re = [ "^" ];
-        this.matchMap = new Map;
-        let pos = 0;
-        const matches = Array.from(template.matchAll(/\{(.+?)\}/g));
-        let matchCounter = 0;
-        for (const m of matches) {
-            if (m.index > pos) {
-                const lit = template.slice(pos, m.index);
-                this.expandParts.push({
-                    type: STR,
-                    value: lit
-                });
-                const groupName = `static${matchCounter++}`;
-                re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
-                this.matchMap.set(groupName, {
-                    type: VarType.STATIC
-                });
-            }
-            pos = m.index + m[0].length;
-            const ph = {
-                type: VAR,
-                prefix: "",
-                vars: []
-            };
-            this.expandParts.push(ph);
-            let varStr = m[1];
-            const prefix = varStr.match(PREFIX_RE);
-            if (prefix) {
-                varStr = varStr.slice(1);
-                ph.prefix = prefix[0];
-            }
-            const vars = varStr.split(",");
-            const isNamed = Named[ph.prefix];
-            let isFirst = true;
-            if (!isNamed) {
-                re.push(escapeRegExp(FirstMap[ph.prefix]));
-            }
-            for (const v of vars) {
-                const item = {
-                    name: v,
-                    length: null,
-                    func: null,
-                    repeat: false
-                };
-                const mod = v.match(MODIFIER_RE);
-                if (mod) {
-                    if (mod.groups.repeat !== undefined) {
-                        item.repeat = true;
-                    }
-                    if (mod.groups.length !== undefined) {
-                        item.length = Number(mod.groups.length);
-                    }
-                    if (mod.groups.func !== undefined) {
-                        item.func = mod.groups.func;
-                    }
-                    item.name = item.name.slice(0, mod.index);
-                }
-                ph.vars.push(item);
-                if (!isNamed) {
-                    if (!isFirst) {
-                        re.push(escapeRegExp(SeparatorMap[ph.prefix]));
-                    }
-                    let groupName = item.name;
-                    if (!/^[a-z][a-z0-9_]*$/i.test(groupName)) {
-                        groupName = "param";
-                    }
-                    groupName += String(matchCounter++);
-                    re.push(`(?<${groupName}>`);
-                    if (item.func != null) {
-                        switch (item.func) {
-                          case "int":
-                            if (item.length != null) {
-                                re.push(`\\d{${item.length}}`);
-                            } else {
-                                re.push("-?\\d+");
-                            }
-                            break;
-
-                          default:
-                            throw new Error(`Unrecognized UriTemplate func: ${item.func}`);
-                        }
-                    } else {
-                        let ch;
-                        if (ph.prefix === "+") {
-                            ch = "[^?#]";
-                        } else if (ph.prefix === "#") {
-                            ch = ".";
-                        } else if (ph.prefix === "/" && item.repeat) {
-                            ch = "[^?#]";
-                        } else {
-                            ch = "[^/?#]";
-                        }
-                        if (item.length != null) {
-                            ch = `(?:%[0-9a-fA-F]{2}|${ch})`;
-                            re.push(ch, `{${item.length}}`);
-                        } else {
-                            re.push(ch, "+?");
-                        }
-                    }
-                    re.push(")");
-                    this.matchMap.set(groupName, {
-                        var: item,
-                        type: VarType.DYNAMIC,
-                        prefix: ph.prefix
-                    });
-                }
-                isFirst = false;
-            }
-            if (isNamed) {
-                re.push("(?:", escapeRegExp(FirstMap[ph.prefix]));
-                const groupName = `kwargs${matchCounter++}`;
-                re.push(`(?<${groupName}>[^/?#]*)`);
-                re.push(")?");
-                this.matchMap.set(groupName, {
-                    vars: ph.vars,
-                    type: VarType.NAMED,
-                    prefix: ph.prefix
-                });
-            }
-        }
-        if (pos < template.length) {
-            const lit = template.slice(pos);
-            this.expandParts.push({
-                type: STR,
-                value: lit
-            });
-            const groupName = `static${matchCounter++}`;
-            re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
-            this.matchMap.set(groupName, {
-                type: VarType.STATIC
-            });
-        }
-        re.push("$");
-        this.matchRegex = new RegExp(re.join(""));
-    }
-    expand(variables) {
-        const out = [];
-        for (const p of this.expandParts) {
-            switch (p.type) {
-              case VAR:
-                const vs = [];
-                for (const v of p.vars) {
-                    if (Object.hasOwn(variables, v.name)) {
-                        const x = variables[v.name];
-                        if (x == null) continue;
-                        const sep = v.repeat ? SeparatorMap[p.prefix] : ",";
-                        const esc = x => percentEncodeRegExp(x, ReservedExpansion[p.prefix], v.length, v.repeat ? "=" : ",");
-                        let pre = "";
-                        if (Named[p.prefix]) {
-                            pre = v.name + (isEmpty(x) ? IfEmp[p.prefix] : "=");
-                        }
-                        if (Array.isArray(x)) {
-                            if (x.length) {
-                                vs.push((v.repeat ? "" : pre) + x.map((z => (v.repeat ? pre : "") + esc(z))).join(sep));
-                            }
-                        } else if (typeof x === "object") {
-                            if (Object.keys(x).length) {
-                                vs.push((v.repeat ? "" : pre) + Object.entries(x).map((([ok, ov]) => `${esc(ok)}${v.repeat ? "=" : ","}${esc(ov)}`)).join(sep));
-                            }
-                        } else {
-                            vs.push(pre + esc(x));
-                        }
-                    }
-                }
-                if (vs.length) {
-                    out.push(FirstMap[p.prefix], vs.join(SeparatorMap[p.prefix]));
-                }
-                break;
-
-              case STR:
-                out.push(p.value);
-                break;
-            }
-        }
-        return out.join("");
-    }
-    match(url) {
-        let score = 0;
-        const m = url.match(this.matchRegex);
-        if (m !== null) {
-            let params = [];
-            if (m.groups != null) {
-                for (const [k, v] of Object.entries(m.groups)) {
-                    const itemSpec = this.matchMap.get(k);
-                    let value;
-                    switch (itemSpec.type) {
-                      case VarType.NAMED:
-                        {
-                            const parsed = v == null ? Object.create(null) : parseParams(v, SeparatorMap[itemSpec.prefix]);
-                            for (const vs of itemSpec.vars) {
-                                if (vs.repeat) {
-                                    score -= 1;
-                                    if (isEmpty(parsed)) {
-                                        params.push([ vs.name, EMPTY_OBJ ]);
-                                    } else {
-                                        params.push([ vs.name, mapValues(parsed, (x => formatElement(x, vs))) ]);
-                                    }
-                                    break;
-                                } else {
-                                    if (parsed[vs.name] !== undefined) {
-                                        score += 2;
-                                        params.push([ vs.name, formatElement(parsed[vs.name], vs) ]);
-                                        delete parsed[vs.name];
-                                    } else {
-                                        params.push([ vs.name, null ]);
-                                    }
-                                }
-                            }
-                        }
-                        break;
-
-                      case VarType.DYNAMIC:
-                        {
-                            score += 2;
-                            if (v == null) {
-                                if (itemSpec.var.repeat) {
-                                    if (Named[itemSpec.prefix]) {
-                                        value = EMPTY_OBJ;
-                                    } else {
-                                        value = EMPTY_ARR;
-                                    }
-                                } else {
-                                    value = null;
-                                }
-                            } else {
-                                value = v;
-                                if (itemSpec.var.repeat) {
-                                    value = value.split(SeparatorMap[itemSpec.prefix]).map((x => formatElement(x, itemSpec.var)));
-                                } else {
-                                    value = formatElement(value, itemSpec.var);
-                                }
-                            }
-                            params.push([ itemSpec.var.name, value ]);
-                        }
-                        break;
-
-                      case VarType.STATIC:
-                        {
-                            score += 3;
-                        }
-                        break;
-                    }
-                }
-            }
-            return {
-                score,
-                params: Object.fromEntries(params)
-            };
-        }
-        return null;
-    }
-}
-
-function formatElement(str, varSpec) {
-    if (str == null) return null;
-    let out = decodeURIComponent(str);
-    if (varSpec.length != null) {
-        out = out.slice(0, varSpec.length);
-    }
-    if (varSpec.func === "int") {
-        out = Number(out);
-    }
-    return out;
-}
-
-function mapValues(obj, callback) {
-    return Object.fromEntries(Object.entries(obj).map((([key, value]) => [ key, callback(value) ])));
-}
-
-function parseParams(queryString, separator) {
-    const pairs = queryString.split(separator);
-    return Object.fromEntries(pairs.map((pair => {
-        const idx = pair.indexOf("=");
-        if (idx === -1) {
-            return [ pair, null ];
-        }
-        const key = pair.slice(0, idx);
-        const value = pair.slice(idx + 1);
-        return [ key, value ];
-    })));
-}
-
-const EMPTY_OBJ = Object.freeze(Object.create(null));
-
-const EMPTY_ARR = Object.freeze([]);
-
-function isEmpty(x) {
-    return x == null || x === "" || (Array.isArray(x) ? !x.length : typeof x === "object" && !Object.keys(x).length);
-}
-
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function fullWide(n) {
-    try {
-        return n.toLocaleString("en-US", {
-            useGrouping: false,
-            maximumFractionDigits: 20
-        });
-    } catch {
-        return n.toFixed(14).replace(/\.?0+$/, "");
-    }
-}
-
-function percentEncodeRegExp(value, reserved, length, separator) {
-    if (typeof value === "number") {
-        return fullWide(value);
-    }
-    if (value === true) return "1";
-    if (value === false) return "0";
-    if (value == null) return "";
-    if (Array.isArray(value)) {
-        return value.map((v => percentEncodeRegExp(v, reserved, length, separator))).join(separator);
-    }
-    if (length != null) {
-        value = value.slice(0, length);
-    }
-    if (reserved) {
-        return value.replace(/%[0-9a-fA-F]{2}|./gsu, (m => {
-            let v = PERCENT_RE.test(m) ? decodeURIComponent(m) : m;
-            if (UR_SET.test(v)) {
-                return percentEncode(v);
-            }
-            return m;
-        }));
-    }
-    return value.replace(UNRESERVED, percentEncode);
-}
-
-const UTF8_ENCODER = new TextEncoder;
-
-function percentEncode(str) {
-    return Array.from(UTF8_ENCODER.encode(str)).map((i => "%" + i.toString(16).toUpperCase().padStart(2, "0"))).join("");
-}
-
-export { UriTemplate };

package/dist/dev.d.ts

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

package/dist/log.d.ts

@@ -1 +0,0 @@
-export default function log(...vars: any): void;

package/dist/uri-template.d.ts

@@ -1,56 +0,0 @@
-declare const STR: unique symbol;
-declare const VAR: unique symbol;
-interface Placeholder {
-    type: typeof VAR;
-    prefix: string;
-    vars: VarSpec[];
-}
-interface StringLiteral {
-    type: typeof STR;
-    value: string;
-}
-type TemplateParts = Array<Placeholder | StringLiteral>;
-interface VarSpec {
-    name: string;
-    /** Max length, in characters. */
-    length: number | null;
-    func: string | null;
-    repeat: boolean;
-}
-declare enum VarType {
-    NAMED = 0,
-    STATIC = 1,
-    DYNAMIC = 2
-}
-type MapItem = {
-    type: VarType.DYNAMIC;
-    var: VarSpec;
-    prefix: string;
-} | {
-    type: VarType.NAMED;
-    vars: VarSpec[];
-    prefix: string;
-} | {
-    type: VarType.STATIC;
-};
-export declare class UriTemplate<P extends UriParams> {
-    expandParts: TemplateParts;
-    matchRegex: RegExp;
-    matchMap: Map<string, MapItem>;
-    constructor(template: string);
-    expand(variables: P): string;
-    match(url: string): UriMatch<P> | null;
-}
-type Primitive = string | number | boolean | null;
-type PrimitivePair = [key: string, value: Primitive];
-type PrimitiveMap = {
-    [K in string]: Primitive;
-};
-export type UrlParamValue = Primitive | Primitive[] | PrimitivePair[] | PrimitiveMap;
-export declare function fullWide(n: number): string;
-export type UriParams = Record<string, UrlParamValue>;
-export type UriMatch<P extends UriParams> = {
-    score: number;
-    params: P;
-};
-export {};