@loozo/angular-router 0.0.0-stage → 0.0.2

package/fesm2022/loozo-angular-router-_core.mjs

@@ -0,0 +1,633 @@
+const presence = new WeakMap();
+function codecPresence(codec) {
+    return presence.get(codec);
+}
+function validateCodec(codec) {
+    if (codec === null ||
+        (typeof codec !== "object" && typeof codec !== "function") ||
+        typeof codec.parse !== "function" ||
+        typeof codec.stringify !== "function") {
+        throw new TypeError("Codec must have callable parse and stringify methods");
+    }
+}
+/**
+ * Preserves strings verbatim, including empty strings and literal percent text.
+ *
+ * @remarks
+ * Empty, dot and dotdot values are valid codec values but cannot be serialized
+ * into path segments by URL creation. Search values may contain them.
+ */
+const stringParam = {
+    parse(raw) {
+        return raw;
+    },
+    stringify(value) {
+        if (typeof value !== "string") {
+            throw new TypeError("Expected a string");
+        }
+        return value;
+    },
+};
+/**
+ * Parses nonblank text with JavaScript `Number` and requires a finite result.
+ *
+ * @remarks
+ * Whitespace around numbers, exponent notation and hexadecimal text are accepted.
+ * Blank text, NaN and infinities throw. Stringification requires a finite number
+ * and uses its JavaScript string representation (including `-0` becoming `"0"`).
+ */
+const numberParam = {
+    parse(raw) {
+        const value = Number(raw);
+        if (raw.trim() === "" || !Number.isFinite(value)) {
+            throw new Error("Expected a finite number");
+        }
+        return value;
+    },
+    stringify(value) {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            throw new Error("Expected a finite number");
+        }
+        return String(value);
+    },
+};
+/**
+ * Parses only lowercase `"true"` and `"false"`, and emits those same strings.
+ * Other representations and nonboolean values throw.
+ */
+const booleanParam = {
+    parse(raw) {
+        if (raw === "true") {
+            return true;
+        }
+        if (raw === "false") {
+            return false;
+        }
+        throw new Error("Expected true or false");
+    },
+    stringify(value) {
+        if (value === true) {
+            return "true";
+        }
+        if (value === false) {
+            return "false";
+        }
+        throw new Error("Expected a boolean");
+    },
+};
+/**
+ * Creates a case-sensitive string codec from a snapshotted list of members.
+ *
+ * @typeParam Values - The literal list from which the value union is inferred.
+ * @param values - Allowed decoded strings; an empty string is valid when listed.
+ * @returns A codec whose parser and stringifier reject nonmembers.
+ * @throws TypeError if the list or its entries are malformed.
+ *
+ * @example
+ * ```ts
+ * const tab = enumParam(["details", "reviews"]);
+ * tab.parse("reviews"); // "reviews"
+ * ```
+ */
+function enumParam(values) {
+    if (!Array.isArray(values)) {
+        throw new TypeError("Enum values must be a string list");
+    }
+    const members = new Set();
+    for (const value of values) {
+        if (typeof value !== "string") {
+            throw new TypeError("Enum values must be strings");
+        }
+        members.add(value);
+    }
+    return {
+        parse(raw) {
+            if (!members.has(raw)) {
+                throw new Error("Unknown enum value");
+            }
+            return raw;
+        },
+        stringify(value) {
+            if (!members.has(value)) {
+                throw new Error("Unknown enum value");
+            }
+            return value;
+        },
+    };
+}
+/**
+ * Makes a search key optional without changing the handling of present values.
+ *
+ * @remarks
+ * Generated parsing omits absent keys; URL creation omits absent or `undefined`
+ * values. The wrapper's parser delegates present strings unchanged, preserving
+ * promises and failures. Its stringifier cannot serialize `undefined` directly.
+ * This wrapper is not a path codec. For optional nullable values, wrap
+ * {@link nullableSearchParam} with this function, not the other way around.
+ *
+ * @typeParam Value - The wrapped codec's logical value.
+ * @param codec - The codec used for present search values.
+ * @returns A search-only codec allowing omission.
+ * @throws TypeError if the codec lacks callable parse/stringify methods.
+ */
+function optionalSearchParam(codec) {
+    validateCodec(codec);
+    const wrapper = {
+        parse(raw) {
+            return codec.parse(raw);
+        },
+        stringify(value) {
+            if (value === undefined) {
+                throw new TypeError("Omitted search has no scalar representation");
+            }
+            return codec.stringify(value);
+        },
+    };
+    presence.set(wrapper, "optional");
+    return wrapper;
+}
+/**
+ * Adds explicit null to a search codec, represented by the decoded text `"null"`.
+ *
+ * @remarks
+ * The key remains required unless wrapped with {@link optionalSearchParam}.
+ * Non-null values delegate unchanged, including promise/failure identity. The
+ * text `"null"` is reserved by this wrapper even if the inner codec accepts it.
+ * This wrapper is not a path codec and cannot wrap an optional search codec.
+ *
+ * @typeParam Value - The wrapped codec's non-null logical value.
+ * @param codec - The codec used for values other than null.
+ * @returns A search-only codec accepting and serializing null.
+ * @throws TypeError if the codec is malformed or is an optional search wrapper.
+ *
+ * @example
+ * ```ts
+ * const score = optionalSearchParam(nullableSearchParam(numberParam));
+ * // Omission, null, and a present number remain distinct.
+ * ```
+ */
+function nullableSearchParam(codec) {
+    validateCodec(codec);
+    if (codecPresence(codec) === "optional") {
+        throw new TypeError("Nullable cannot wrap optional");
+    }
+    const wrapper = {
+        parse(raw) {
+            if (raw === "null") {
+                return null;
+            }
+            return codec.parse(raw);
+        },
+        stringify(value) {
+            if (value === null) {
+                return "null";
+            }
+            return codec.stringify(value);
+        },
+    };
+    presence.set(wrapper, "nullable");
+    return wrapper;
+}
+
+function parsePath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError("Path must be a string");
+    }
+    if (path === "") {
+        return Object.freeze([]);
+    }
+    const segments = [];
+    const scalarNames = new Set();
+    const parts = path.split("/");
+    for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
+        if (part.startsWith("$")) {
+            let name = part.slice(1);
+            let kind = "scalar";
+            if (name.endsWith("[]")) {
+                name = name.slice(0, -2);
+                kind = "catchall";
+            }
+            if (name === "" ||
+                name === "__proto__" ||
+                name.startsWith("...") ||
+                name.includes("?") ||
+                name.includes("*") ||
+                name.includes("[]")) {
+                throw new TypeError(`Invalid parameter name: ${name}`);
+            }
+            if (kind === "catchall" && (index !== parts.length - 1 || scalarNames.has(name))) {
+                throw new TypeError("Catchall must be terminal and cannot repeat a scalar name");
+            }
+            scalarNames.add(name);
+            segments.push(Object.freeze({ kind, name }));
+        }
+        else {
+            if (part === "" ||
+                part === "." ||
+                part === ".." ||
+                part === "*" ||
+                part === "**" ||
+                part.startsWith(":")) {
+                throw new TypeError(`Invalid static segment: ${part}`);
+            }
+            if (!part.isWellFormed()) {
+                throw new TypeError("Static path Unicode must be well formed");
+            }
+            segments.push(Object.freeze({ kind: "static", text: part }));
+        }
+    }
+    return Object.freeze(segments);
+}
+
+function ownRecord(value, label, allowSymbols = false) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an own record`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${label} cannot contain inherited entries`);
+    }
+    for (const key of Reflect.ownKeys(value)) {
+        if ((!allowSymbols && typeof key !== "string") ||
+            !Object.prototype.propertyIsEnumerable.call(value, key)) {
+            throw new TypeError(`${label} contains an unsupported key`);
+        }
+    }
+    return value;
+}
+function checkKeys(record, allowed, label) {
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key)) {
+            throw new TypeError(`Unknown ${label} key: ${key}`);
+        }
+    }
+}
+function has(record, key) {
+    return Object.hasOwn(record, key);
+}
+
+const routes = new WeakMap();
+const configKeys = new Set([
+    "parent",
+    "params",
+    "search",
+    "resolve",
+    "runGuardsAndResolvers",
+    "redirect",
+    "fragments",
+    "canActivate",
+    "canActivateChild",
+    "canMatch",
+    "canDeactivate",
+    "providers",
+    "title",
+    "data",
+]);
+const policies = new Set([
+    "pathParamsChange",
+    "pathParamsOrQueryParamsChange",
+    "paramsChange",
+    "paramsOrQueryParamsChange",
+    "always",
+]);
+const identityKey = "__loozoAngularRouterRouteId";
+function routeMetadata(route) {
+    if (route === null || typeof route !== "object" || !routes.has(route)) {
+        throw new TypeError("Expected a genuine route from this package instance");
+    }
+    return routes.get(route);
+}
+function copyCodecs(value, path) {
+    const record = ownRecord(value, "Codec map");
+    const result = Object.create(null);
+    for (const key of Object.keys(record)) {
+        const codec = record[key];
+        validateCodec(codec);
+        if (path && codecPresence(codec) !== undefined) {
+            throw new TypeError("Search wrappers cannot be path codecs");
+        }
+        result[key] = codec;
+    }
+    return Object.freeze(result);
+}
+function snapshotRedirect(value, source) {
+    const redirect = ownRecord(value, "Redirect");
+    checkKeys(redirect, new Set(["to", "params", "search", "fragment"]), "redirect");
+    const target = routeMetadata(redirect.to);
+    const mapping = Object.create(null);
+    if (has(redirect, "params")) {
+        const supplied = ownRecord(redirect.params, "Redirect params");
+        checkKeys(supplied, new Set(Object.keys(target.params)), "redirect params");
+        for (const key of Object.keys(target.params)) {
+            const sourceKey = supplied[key];
+            if (!has(supplied, key) || typeof sourceKey !== "string" || !has(source.params, sourceKey)) {
+                throw new TypeError(`Missing or invalid redirect mapping: ${key}`);
+            }
+            mapping[key] = sourceKey;
+        }
+    }
+    else {
+        for (const key of Object.keys(target.params)) {
+            if (!has(source.params, key)) {
+                throw new TypeError(`Cannot forward redirect param: ${key}`);
+            }
+            mapping[key] = key;
+        }
+    }
+    const search = ownRecord(redirect.search, "Redirect search");
+    let searchSnapshot;
+    if (search.mode === "replace") {
+        checkKeys(search, new Set(["mode", "values"]), "redirect search");
+        const values = ownRecord(search.values, "Redirect replacement");
+        validateSearchValues(target.search, values);
+        searchSnapshot = { mode: "replace", values: Object.freeze({ ...values }) };
+    }
+    else if (search.mode === "preserve" || search.mode === "drop") {
+        checkKeys(search, new Set(["mode"]), "redirect search");
+        for (const key of Object.keys(target.search)) {
+            if (codecPresence(target.search[key]) === "optional") {
+                continue;
+            }
+            if (search.mode === "drop" ||
+                !has(source.search, key) ||
+                codecPresence(source.search[key]) === "optional") {
+                throw new TypeError(`Redirect cannot guarantee required search: ${key}`);
+            }
+        }
+        searchSnapshot = { mode: search.mode };
+    }
+    else {
+        throw new TypeError("Invalid redirect search policy");
+    }
+    const fragment = ownRecord(redirect.fragment, "Redirect fragment");
+    if (fragment.mode === "replace") {
+        checkKeys(fragment, new Set(["mode", "value"]), "redirect fragment");
+        if (typeof fragment.value !== "string" || !target.fragments.includes(fragment.value)) {
+            throw new TypeError("Redirect fragment must belong to target declaration");
+        }
+    }
+    else if (fragment.mode === "preserve" || fragment.mode === "drop") {
+        checkKeys(fragment, new Set(["mode"]), "redirect fragment");
+    }
+    else {
+        throw new TypeError("Invalid redirect fragment policy");
+    }
+    return Object.freeze({
+        to: redirect.to,
+        params: Object.freeze(mapping),
+        search: Object.freeze(searchSnapshot),
+        fragment: Object.freeze({ ...fragment }),
+    });
+}
+function validateSearchValues(codecs, values) {
+    checkKeys(values, new Set(Object.keys(codecs)), "search values");
+    for (const key of Object.keys(codecs)) {
+        if (codecPresence(codecs[key]) !== "optional" && !has(values, key)) {
+            throw new TypeError(`Missing required search: ${key}`);
+        }
+    }
+}
+function defineRoute(path, config) {
+    const supplied = ownRecord(config, "Route config");
+    checkKeys(supplied, configKeys, "route config");
+    const localSegments = parsePath(path);
+    let parent;
+    let inherited;
+    if (has(supplied, "parent")) {
+        inherited = routeMetadata(supplied.parent);
+        parent = supplied.parent;
+        for (const segment of inherited.segments) {
+            if (segment.kind === "catchall") {
+                throw new TypeError("Catchall declarations cannot have children");
+            }
+        }
+    }
+    const localNames = new Set();
+    for (const segment of localSegments) {
+        if (segment.kind !== "static") {
+            localNames.add(segment.name);
+        }
+    }
+    let localParams = Object.freeze(Object.create(null));
+    if (localNames.size === 0) {
+        if (has(supplied, "params")) {
+            throw new TypeError("Static paths cannot declare params");
+        }
+    }
+    else {
+        localParams = copyCodecs(supplied.params, true);
+        checkKeys(localParams, localNames, "local params");
+        for (const key of localNames) {
+            if (!has(localParams, key)) {
+                throw new TypeError(`Missing local codec: ${key}`);
+            }
+            if (inherited && has(inherited.params, key)) {
+                throw new TypeError(`Inherited param already owned: ${key}`);
+            }
+        }
+    }
+    let localSearch = Object.freeze(Object.create(null));
+    if (has(supplied, "search")) {
+        localSearch = copyCodecs(supplied.search, false);
+    }
+    for (const key of Object.keys(localSearch)) {
+        if (inherited && has(inherited.search, key)) {
+            throw new TypeError(`Inherited search already owned: ${key}`);
+        }
+    }
+    const retained = { ...supplied };
+    const result = { path: path };
+    if (has(supplied, "resolve")) {
+        const resolve = ownRecord(supplied.resolve, "Resolvers", true);
+        const copied = Object.create(null);
+        for (const key of Reflect.ownKeys(resolve)) {
+            if (key === identityKey || typeof resolve[key] !== "function") {
+                throw new TypeError(`Invalid resolver: ${String(key)}`);
+            }
+            copied[key] = resolve[key];
+        }
+        result.resolve = Object.freeze(copied);
+        retained.resolve = result.resolve;
+    }
+    if (has(supplied, "runGuardsAndResolvers")) {
+        const policy = supplied.runGuardsAndResolvers;
+        if (typeof policy !== "function" && (typeof policy !== "string" || !policies.has(policy))) {
+            throw new TypeError("Invalid native rerun policy");
+        }
+        result.runGuardsAndResolvers = policy;
+    }
+    for (const key of ["canActivate", "canActivateChild", "canMatch", "canDeactivate", "providers"]) {
+        if (!has(supplied, key)) {
+            continue;
+        }
+        const list = supplied[key];
+        if (!Array.isArray(list)) {
+            throw new TypeError(`${key} must be an array`);
+        }
+        if (key === "canActivate" || key === "canActivateChild" || key === "canMatch") {
+            for (const callback of list) {
+                if (typeof callback !== "function") {
+                    throw new TypeError(`${key} entries must be callbacks`);
+                }
+            }
+        }
+        else if (key === "canDeactivate") {
+            for (const guard of list) {
+                if (guard === null ||
+                    (typeof guard !== "function" && typeof guard !== "object" && typeof guard !== "string")) {
+                    throw new TypeError("canDeactivate entries must be native callbacks or tokens");
+                }
+            }
+        }
+        retained[key] = Object.freeze([...list]);
+    }
+    if (has(supplied, "title") &&
+        typeof supplied.title !== "string" &&
+        typeof supplied.title !== "function") {
+        throw new TypeError("Invalid native title");
+    }
+    if (has(supplied, "data")) {
+        const data = ownRecord(supplied.data, "Static data", true);
+        if (has(data, identityKey)) {
+            throw new TypeError("Static data cannot set generated identity");
+        }
+        retained.data = Object.freeze({ ...data });
+    }
+    const fragments = [];
+    if (has(supplied, "fragments")) {
+        if (!Array.isArray(supplied.fragments)) {
+            throw new TypeError("Fragments must be a string list");
+        }
+        for (const name of supplied.fragments) {
+            if (typeof name !== "string") {
+                throw new TypeError("Fragment names must be strings");
+            }
+            fragments.push(name);
+        }
+    }
+    retained.fragments = Object.freeze(fragments);
+    retained.params = localParams;
+    retained.search = localSearch;
+    const metadata = {
+        parent,
+        localSegments,
+        segments: Object.freeze([...(inherited?.segments ?? []), ...localSegments]),
+        localParams,
+        localSearch,
+        params: Object.freeze({ ...inherited?.params, ...localParams }),
+        search: Object.freeze({ ...inherited?.search, ...localSearch }),
+        fragments: retained.fragments,
+        config: retained,
+    };
+    if (has(supplied, "redirect")) {
+        if (has(supplied, "canActivate") || has(supplied, "canMatch")) {
+            throw new TypeError("Redirect cannot declare own canActivate or canMatch");
+        }
+        retained.redirect = snapshotRedirect(supplied.redirect, metadata);
+    }
+    Object.freeze(retained);
+    routes.set(result, Object.freeze(metadata));
+    return Object.freeze(result);
+}
+
+function encode(value) {
+    return encodeURIComponent(value).replaceAll("(", "%28").replaceAll(")", "%29");
+}
+function stringify(codec, value, path) {
+    const text = codec.stringify(value);
+    if (typeof text !== "string") {
+        throw new TypeError("Codec stringify must return a string");
+    }
+    if (path && (text === "" || text === "." || text === "..")) {
+        throw new TypeError("Path output cannot be empty, dot or dotdot");
+    }
+    return encode(text);
+}
+function createUrl(route, values) {
+    const metadata = routeMetadata(route);
+    const options = ownRecord(values, "URL options");
+    checkKeys(options, new Set(["params", "search", "fragment"]), "URL options");
+    const paramKeys = Object.keys(metadata.params);
+    let params = Object.create(null);
+    if (paramKeys.length === 0) {
+        if (has(options, "params")) {
+            throw new TypeError("Route has no path params");
+        }
+    }
+    else {
+        params = ownRecord(options.params, "Path values");
+        checkKeys(params, new Set(paramKeys), "path values");
+        for (const key of paramKeys) {
+            if (!has(params, key)) {
+                throw new TypeError(`Missing path value: ${key}`);
+            }
+        }
+    }
+    const searchKeys = Object.keys(metadata.search).sort();
+    let search = Object.create(null);
+    if (searchKeys.length === 0) {
+        if (has(options, "search")) {
+            throw new TypeError("Route has no search declarations");
+        }
+    }
+    else {
+        if (has(options, "search")) {
+            search = ownRecord(options.search, "Search values");
+        }
+        validateSearchValues(metadata.search, search);
+    }
+    if (has(options, "fragment")) {
+        if (typeof options.fragment !== "string" || !metadata.fragments.includes(options.fragment)) {
+            throw new TypeError("Fragment must belong to this declaration");
+        }
+    }
+    // Check all cardinalities before invoking application stringifiers.
+    for (const segment of metadata.segments) {
+        if (segment.kind === "catchall" && !Array.isArray(params[segment.name])) {
+            throw new TypeError(`Catchall requires an array: ${segment.name}`);
+        }
+    }
+    const parts = [];
+    for (const segment of metadata.segments) {
+        if (segment.kind === "static") {
+            parts.push(encode(segment.text));
+        }
+        else if (segment.kind === "scalar") {
+            parts.push(stringify(metadata.params[segment.name], params[segment.name], true));
+        }
+        else {
+            for (const value of params[segment.name]) {
+                parts.push(stringify(metadata.params[segment.name], value, true));
+            }
+        }
+    }
+    let url = `/${parts.join("/")}`;
+    const query = [];
+    for (const key of searchKeys) {
+        const codec = metadata.search[key];
+        const optional = codecPresence(codec) === "optional";
+        if (optional && !has(search, key)) {
+            continue;
+        }
+        const value = search[key];
+        if (optional && value === undefined) {
+            continue;
+        }
+        query.push(`${encode(key)}=${stringify(codec, value, false)}`);
+    }
+    if (query.length > 0) {
+        url += `?${query.join("&")}`;
+    }
+    if (has(options, "fragment")) {
+        url += `#${encode(options.fragment)}`;
+    }
+    return url;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { booleanParam, codecPresence, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, routeMetadata, stringParam };
+//# sourceMappingURL=loozo-angular-router-_core.mjs.map