@occultist/occultist 0.0.1

package/dist/utils/getRequestIRIValues.js

@@ -0,0 +1,133 @@
+import { ProblemDetailsError } from "../errors.js";
+import { getParamLocation } from "./getParamLocation.js";
+export function getRequestIRIValues({ iri, action, }) {
+    const pathValues = {};
+    const queryValues = {};
+    // deno-lint-ignore no-explicit-any
+    const iriValues = {};
+    const urlPatternResult = action.pattern.exec(iri);
+    const pathParams = urlPatternResult?.pathname.groups || {};
+    const searchParams = new URL(iri).searchParams;
+    const valueNames = Object.values(action.spec)
+        .filter((specItem) => typeof specItem.valueName === 'string')
+        .map((specItem) => specItem.valueName);
+    //if (action.strict) {
+    for (const valueName of searchParams.keys()) {
+        if (!valueNames.includes(valueName)) {
+            throw new ProblemDetailsError(400, {
+                title: `Unexpected value "${valueName}"`,
+            });
+        }
+    }
+    //}
+    for (const [term, specItem] of Object.entries(action.spec)) {
+        if (typeof specItem.valueName !== 'string') {
+            continue;
+        }
+        let value;
+        const valueName = specItem.valueName;
+        const multipleValues = Boolean(specItem.multipleValues);
+        const paramLocation = getParamLocation(valueName, action.pattern);
+        if (paramLocation === 'path') {
+            value = pathParams[valueName];
+        }
+        else {
+            value = searchParams.getAll(valueName);
+        }
+        if (value === null) {
+            value = undefined;
+        }
+        if (!multipleValues && Array.isArray(value) && value.length > 1) {
+            throw new ProblemDetailsError(400, {
+                title: `Invalid request`,
+                errors: [{
+                        name: term,
+                        pointer: `#${term}`,
+                        reason: `Received array when expecting single value`,
+                    }],
+            });
+        }
+        if (multipleValues && typeof value === 'string') {
+            value = [value];
+        }
+        else if (!multipleValues && Array.isArray(value)) {
+            value = value[0];
+        }
+        if (typeof value === 'undefined') {
+            continue;
+        }
+        else if (!specItem.valueRequired && Array.isArray(value) && value.length === 0) {
+            continue;
+        }
+        if (specItem.dataType === 'boolean' && typeof value === 'string') {
+            iriValues[term] = parseBoolean({
+                term,
+                value,
+                pointer: `#${term}`,
+            });
+        }
+        else if (specItem.dataType === 'boolean' && Array.isArray(value)) {
+            iriValues[term] = value.map((value, index) => parseBoolean({
+                term,
+                value,
+                pointer: `#${term}[${index}]`,
+            }));
+        }
+        else if (specItem.dataType === 'number' && typeof value === 'string') {
+            iriValues[term] = parseNumber({
+                term,
+                value,
+                pointer: `#${term}`,
+            });
+        }
+        else if (specItem.dataType === 'number' && Array.isArray(value)) {
+            iriValues[term] = value.map((value, index) => parseNumber({
+                term,
+                value,
+                pointer: `#${term}[${index}]`,
+            }));
+        }
+        else {
+            // string values don't require parsing
+            iriValues[term] = value;
+        }
+        if (paramLocation === 'path') {
+            pathValues[term] = iriValues[term];
+        }
+        else {
+            queryValues[term] = iriValues[term];
+        }
+    }
+    return {
+        pathValues,
+        queryValues,
+        iriValues,
+    };
+}
+function parseBoolean({ term, value, pointer, }) {
+    if (!['', 'true', 'false'].includes(value)) {
+        throw new ProblemDetailsError(400, {
+            title: `Invalid request`,
+            errors: [{
+                    name: term,
+                    pointer,
+                    reason: `Boolean values must be "", "true" or "false"`,
+                }],
+        });
+    }
+    return value === '' || value === 'true';
+}
+function parseNumber({ term, value, pointer, }) {
+    const numberValue = Number(value);
+    if (isNaN(numberValue) || !Number.isFinite(numberValue)) {
+        throw new ProblemDetailsError(400, {
+            title: `Invalid request`,
+            errors: [{
+                    name: term,
+                    pointer,
+                    reason: `Numeric values must valid numbers and finite`,
+                }],
+        });
+    }
+    return numberValue;
+}

package/dist/utils/isBodyInit.d.ts

@@ -0,0 +1 @@
+export declare function isBodyInit(value: unknown): value is BodyInit;

package/dist/utils/isBodyInit.js

@@ -0,0 +1,21 @@
+export function isBodyInit(value) {
+    return value instanceof ReadableStream ||
+        value instanceof Blob ||
+        value instanceof DataView ||
+        value instanceof ArrayBuffer ||
+        value instanceof Int8Array ||
+        value instanceof Uint8Array ||
+        value instanceof Uint8ClampedArray ||
+        value instanceof Int16Array ||
+        value instanceof Uint16Array ||
+        value instanceof Int32Array ||
+        value instanceof Uint32Array ||
+        value instanceof Float16Array ||
+        value instanceof Float32Array ||
+        value instanceof Float64Array ||
+        value instanceof BigInt64Array ||
+        value instanceof BigUint64Array ||
+        value instanceof FormData ||
+        value instanceof URLSearchParams ||
+        typeof value === 'string';
+}

package/dist/utils/isNil.d.ts

@@ -0,0 +1 @@
+export declare function isNil(value: any): value is null | undefined;

package/dist/utils/isNil.js

@@ -0,0 +1,4 @@
+// deno-lint-ignore no-explicit-any
+export function isNil(value) {
+    return typeof value === 'undefined' || value === null;
+}

package/dist/utils/isObject.d.ts

@@ -0,0 +1,6 @@
+type ObjectValue = Record<string | number | symbol, unknown>;
+/**
+ * Returns true if the input value is a plain Javascript object.
+ */
+export declare function isObject<T extends ObjectValue = ObjectValue>(value: unknown): value is T;
+export {};

package/dist/utils/isObject.js

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the input value is a plain Javascript object.
+ */
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/utils/isPopulatedObject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the input value is a plain Javascript object with
+ * at least one member.
+ */
+export declare function isPopulatedObject<ChildType>(value: unknown): value is Record<string, ChildType>;

package/dist/utils/isPopulatedObject.js

@@ -0,0 +1,8 @@
+import { isObject } from './isObject.js';
+/**
+ * Returns true if the input value is a plain Javascript object with
+ * at least one member.
+ */
+export function isPopulatedObject(value) {
+    return isObject(value) && Object.keys(value).length > 0;
+}

package/dist/utils/isPopulatedString.d.ts

@@ -0,0 +1 @@
+export declare function isPopulatedString(value: any): value is string;

package/dist/utils/isPopulatedString.js

@@ -0,0 +1,4 @@
+// deno-lint-ignore no-explicit-any
+export function isPopulatedString(value) {
+    return typeof value === 'string' && value.length !== 0;
+}

package/dist/utils/joinPaths.d.ts

@@ -0,0 +1 @@
+export declare function joinPaths(...paths: Array<string | number>): string;

package/dist/utils/joinPaths.js

@@ -0,0 +1,31 @@
+export function joinPaths(...paths) {
+    let fullPath = '';
+    if (paths[0] == null || paths[0] == '') {
+        throw new Error('The first path must be a populated string when joining paths');
+    }
+    for (const pathSrc of paths) {
+        let path = null;
+        if (typeof pathSrc === 'number') {
+            path = `${pathSrc}`;
+        }
+        else if (typeof pathSrc === 'string') {
+            path = pathSrc;
+        }
+        if (path == null || path == '') {
+            continue;
+        }
+        if (fullPath === '') {
+            fullPath = path;
+        }
+        else if (fullPath.endsWith('/') && path.startsWith('/')) {
+            fullPath += path.replace(/^\//, '');
+        }
+        else if (fullPath.endsWith('/') || path.startsWith('/')) {
+            fullPath += path;
+        }
+        else {
+            fullPath += `/${path}`;
+        }
+    }
+    return fullPath;
+}

package/dist/utils/makeAppendProblemDetails.d.ts

@@ -0,0 +1,14 @@
+import type { ProblemDetailsParam, ProblemDetails } from '../types.js';
+export type AppendProblemDetails = (args: {
+    status: number;
+    title?: string;
+    detail?: string;
+    param?: ProblemDetailsParam;
+}) => void;
+export type ProblemDetailsParamsRefs = {
+    title?: string;
+    detail?: string;
+    httpStatus?: number;
+    problemDetails?: ProblemDetails;
+};
+export declare function makeAppendProblemDetails(refs: ProblemDetailsParamsRefs): AppendProblemDetails;

package/dist/utils/makeAppendProblemDetails.js

@@ -0,0 +1,26 @@
+export function makeAppendProblemDetails(refs) {
+    function appendProblemDetails({ title, detail, status, param, }) {
+        if (refs.httpStatus == null) {
+            refs.httpStatus = status;
+        }
+        else if (refs.httpStatus !== status &&
+            refs.httpStatus < 400) {
+            refs.httpStatus = status;
+        }
+        if (!refs.problemDetails) {
+            refs.problemDetails = {
+                title: title ??= "Bad request",
+                detail: detail ??= "Invalid parameters",
+            };
+        }
+        if (param) {
+            if (!Array.isArray(refs.problemDetails.errors)) {
+                refs.problemDetails.errors = [param];
+            }
+            else {
+                refs.problemDetails.errors.push(param);
+            }
+        }
+    }
+    return appendProblemDetails;
+}

package/dist/utils/makeURLPattern.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Work-around for how URLPatterns are currently supported across runtimes.
+ * This requires node v23 and above to run.
+ */
+export declare function makeURLPattern(pattern: string, baseURL: string): URLPattern;

package/dist/utils/makeURLPattern.js

@@ -0,0 +1,12 @@
+import url from 'node:url';
+/**
+ * Work-around for how URLPatterns are currently supported across runtimes.
+ * This requires node v23 and above to run.
+ */
+export function makeURLPattern(pattern, baseURL) {
+    if (typeof URLPattern === 'undefined') {
+        const URLPattern = url.URLPattern;
+        return new URLPattern(pattern, baseURL);
+    }
+    return new URLPattern(pattern, baseURL);
+}

package/dist/utils/normalizeURL.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Maps the URL of the request to the root IRI.
+ */
+export declare function normalizeURL(rootIRI: string, urlStr: string): string;

package/dist/utils/normalizeURL.js

@@ -0,0 +1,11 @@
+/**
+ * Maps the URL of the request to the root IRI.
+ */
+export function normalizeURL(rootIRI, urlStr) {
+    const sourceURL = new URL(urlStr);
+    const targetURL = new URL(rootIRI);
+    targetURL.pathname = sourceURL.pathname;
+    targetURL.search = sourceURL.search;
+    targetURL.hash = sourceURL.hash;
+    return targetURL.toString();
+}

package/dist/utils/parseSearchParams.d.ts

@@ -0,0 +1,3 @@
+import type { ActionSpec, ContextState } from "../actions/spec.js";
+import type { EmptyObject, JSONObject } from "../jsonld.js";
+export declare function parseSearchParams<ActionState extends ContextState = EmptyObject>(spec: ActionSpec<ActionState>, searchParams: URLSearchParams): JSONObject;

package/dist/utils/parseSearchParams.js

@@ -0,0 +1,24 @@
+export function parseSearchParams(spec, searchParams) {
+    const body = {};
+    for (const [key, specItem] of Object.entries(spec)) {
+        const value = searchParams.get(key);
+        if (specItem.dataType === "number" &&
+            Array.isArray(value) &&
+            value !== null) {
+            body[key] = value.map(Number);
+        }
+        else if (specItem.dataType === "number" &&
+            value !== null &&
+            isNaN(Number(value))) {
+            // keeping the number value as a string allows error handling to work with it
+            body[key] = value;
+        }
+        else if (specItem.dataType === "number" && value !== null) {
+            body[key] = Number(value);
+        }
+        else if (value !== null) {
+            body[key] = value;
+        }
+    }
+    return body;
+}

package/dist/utils/preferredMediaTypes.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Adapted directly from negotiator at https://github.com/jshttp/negotiator/
+ * which is licensed as follows:
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2012-2014 Federico Romero
+ * Copyright (c) 2012-2014 Isaac Z. Schlueter
+ * Copyright (c) 2014-2015 Douglas Christopher Wilson
+ *
+ * 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.
+ */
+/**
+ * Taken from deno source as they do not export it publicly
+ * https://jsr.io/@std/http/1.0.16/_negotiation/media_type.js
+ */
+export interface Specificity {
+    i: number;
+    o: number | undefined;
+    q: number;
+    s: number | undefined;
+}
+export declare function compareSpecs(a: Specificity, b: Specificity): number;
+export declare function isQuality(spec: Specificity): boolean;
+export declare function preferredMediaTypes(accept?: string | null, provided?: string[]): string[];

package/dist/utils/preferredMediaTypes.js

@@ -0,0 +1,149 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+/*!
+ * Adapted directly from negotiator at https://github.com/jshttp/negotiator/
+ * which is licensed as follows:
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2012-2014 Federico Romero
+ * Copyright (c) 2012-2014 Isaac Z. Schlueter
+ * Copyright (c) 2014-2015 Douglas Christopher Wilson
+ *
+ * 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.
+ */
+export function compareSpecs(a, b) {
+    return (b.q - a.q ||
+        (b.s ?? 0) - (a.s ?? 0) ||
+        (a.o ?? 0) - (b.o ?? 0) ||
+        a.i - b.i ||
+        0);
+}
+export function isQuality(spec) {
+    return spec.q > 0;
+}
+const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+function splitKeyValuePair(str) {
+    const [key, value] = str.split("=");
+    return [key.toLowerCase(), value];
+}
+function parseMediaType(str, i) {
+    const match = simpleMediaTypeRegExp.exec(str);
+    if (!match) {
+        return;
+    }
+    const [, type, subtype, parameters] = match;
+    if (!type || !subtype) {
+        return;
+    }
+    const params = Object.create(null);
+    let q = 1;
+    if (parameters) {
+        const kvps = parameters.split(";").map((p) => p.trim()).map(splitKeyValuePair);
+        for (const [key, val] of kvps) {
+            const value = val && val[0] === `"` && val[val.length - 1] === `"`
+                ? val.slice(1, val.length - 1)
+                : val;
+            if (key === "q" && value) {
+                q = parseFloat(value);
+                break;
+            }
+            params[key] = value;
+        }
+    }
+    return { type, subtype, params, i, o: undefined, q, s: undefined };
+}
+function parseAccept(accept) {
+    const accepts = accept.split(",").map((p) => p.trim());
+    const mediaTypes = [];
+    for (const [index, accept] of accepts.entries()) {
+        const mediaType = parseMediaType(accept.trim(), index);
+        if (mediaType) {
+            mediaTypes.push(mediaType);
+        }
+    }
+    return mediaTypes;
+}
+function getFullType(spec) {
+    return `${spec.type}/${spec.subtype}`;
+}
+function specify(type, spec, index) {
+    const p = parseMediaType(type, index);
+    if (!p) {
+        return;
+    }
+    let s = 0;
+    if (spec.type.toLowerCase() === p.type.toLowerCase()) {
+        s |= 4;
+    }
+    else if (spec.type !== "*") {
+        return;
+    }
+    if (spec.subtype.toLowerCase() === p.subtype.toLowerCase()) {
+        s |= 2;
+    }
+    else if (spec.subtype !== "*") {
+        return;
+    }
+    const keys = Object.keys(spec.params);
+    if (keys.length) {
+        if (keys.every((key) => (spec.params[key] ?? "").toLowerCase() ===
+            (p.params[key] ?? "").toLowerCase())) {
+            s |= 1;
+        }
+        else {
+            return;
+        }
+    }
+    return {
+        i: index,
+        o: spec.o,
+        q: spec.q,
+        s,
+    };
+}
+function getMediaTypePriority(type, accepted, index) {
+    let priority = { o: -1, q: 0, s: 0, i: index };
+    for (const accepts of accepted) {
+        const spec = specify(type, accepts, index);
+        if (spec &&
+            ((priority.s ?? 0) - (spec.s ?? 0) ||
+                (priority.q ?? 0) - (spec.q ?? 0) ||
+                (priority.o ?? 0) - (spec.o ?? 0)) < 0) {
+            priority = spec;
+        }
+    }
+    return priority;
+}
+export function preferredMediaTypes(accept, provided) {
+    const accepts = parseAccept(accept === undefined ? "*/*" : accept ?? "");
+    if (!provided) {
+        return accepts
+            .filter(isQuality)
+            .sort(compareSpecs)
+            .map(getFullType);
+    }
+    const priorities = provided.map((type, index) => {
+        return getMediaTypePriority(type, accepts, index);
+    });
+    return priorities
+        .filter(isQuality)
+        .sort(compareSpecs)
+        .map((priority) => provided[priorities.indexOf(priority)]);
+}

package/dist/utils/urlToIRI.d.ts

@@ -0,0 +1 @@
+export declare function urlToIRI(value: string, rootIRI: string): string;

package/dist/utils/urlToIRI.js

@@ -0,0 +1,8 @@
+export function urlToIRI(value, rootIRI) {
+    const url = new URL(value);
+    const iri = new URL(rootIRI);
+    iri.pathname = url.pathname;
+    iri.search = url.search;
+    iri.hash = url.hash;
+    return iri.toString();
+}

package/dist/utils/validateSpecValue.d.ts

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

package/dist/utils/validateSpecValue.js

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

package/dist/validators.d.ts

@@ -0,0 +1,16 @@
+import { ArraySpec, ObjectArraySpec, ObjectSpec, PropertySpec } from './actions/spec.js';
+import { JSONValue } from "./jsonld.js";
+export declare function isFileData(value: JSONValue | File): value is string | File;
+export declare function isObjectArraySpec(spec: PropertySpec): spec is ObjectArraySpec;
+export declare function isObjectSpec(spec: PropertySpec): spec is ObjectSpec;
+export declare function isArraySpec(spec: PropertySpec): spec is ArraySpec;
+export declare function failsRequiredRequirement(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failsTypeRequirement(value: JSONValue | File, specValue: PropertySpec): boolean;
+export declare function failsContentTypeRequirement(value: JSONValue | File, specValue: PropertySpec): boolean;
+export declare function failsMinValue(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failsMaxValue(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failsStepValue(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failsPatternValue(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failValueMinLength(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failValueMaxLength(value: JSONValue, specValue: PropertySpec): boolean;
+export declare function failsValidator(value: JSONValue | File, specValue: PropertySpec): boolean;