toolcraft 0.0.115 → 0.0.117

package/node_modules/toolcraft-schema/dist/json-schema/utils.js

@@ -0,0 +1,171 @@
+export function isSchema(value) {
+    return typeof value === "boolean" || isObject(value);
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function dialectFor(schema, inherited) {
+    const dialect = schema.$schema;
+    if (typeof dialect !== "string") {
+        return inherited;
+    }
+    if (dialect.includes("draft-07")) {
+        return "draft7";
+    }
+    if (dialect.includes("2020-12")) {
+        return "draft2020-12";
+    }
+    return inherited;
+}
+export function resolveUri(reference, baseUri) {
+    try {
+        return new URL(reference, baseUri).href;
+    }
+    catch {
+        throw new Error(`Invalid schema URI: ${reference}`);
+    }
+}
+export function withoutFragment(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? uri : uri.slice(0, index);
+}
+export function fragmentOf(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? "" : uri.slice(index + 1);
+}
+export function escapePointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function decodePointer(value) {
+    return decodeURIComponent(value).replaceAll("~1", "/").replaceAll("~0", "~");
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (typeof left !== typeof right || left === null || right === null) {
+        return false;
+    }
+    if (Array.isArray(left)) {
+        return (Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => deepEqual(value, right[index])));
+    }
+    if (isObject(left) && isObject(right)) {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])));
+    }
+    return false;
+}
+export function receivedType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return "integer";
+    }
+    return typeof value;
+}
+export function issue(path, expected, value, message, keyword = keywordFor(expected)) {
+    return { path, expected, received: receivedType(value), message, keyword };
+}
+function keywordFor(expected) {
+    if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
+        return "type";
+    }
+    if (expected.startsWith("multiple of"))
+        return "multipleOf";
+    if (expected.startsWith("length <="))
+        return "maxLength";
+    if (expected.startsWith("length >="))
+        return "minLength";
+    if (expected.startsWith("pattern "))
+        return "pattern";
+    if (expected.startsWith("items <="))
+        return "maxItems";
+    if (expected.startsWith("items >="))
+        return "minItems";
+    if (expected === "unique items")
+        return "uniqueItems";
+    if (expected.startsWith("properties <="))
+        return "maxProperties";
+    if (expected.startsWith("properties >="))
+        return "minProperties";
+    if (expected.startsWith("<= "))
+        return "maximum";
+    if (expected.startsWith(">= "))
+        return "minimum";
+    if (expected.startsWith("< "))
+        return "exclusiveMaximum";
+    if (expected.startsWith("> "))
+        return "exclusiveMinimum";
+    if (expected === "valid schema")
+        return "false schema";
+    return expected;
+}
+export function validResult() {
+    return {
+        valid: true,
+        issues: [],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function invalidResult(problem) {
+    return {
+        valid: false,
+        issues: [problem],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function mergeResults(results) {
+    const merged = validResult();
+    for (const result of results) {
+        merged.valid &&= result.valid;
+        merged.issues.push(...result.issues);
+        for (const key of result.evaluatedProperties) {
+            merged.evaluatedProperties.add(key);
+        }
+        for (const index of result.evaluatedItems) {
+            merged.evaluatedItems.add(index);
+        }
+    }
+    return merged;
+}
+export function typeMatches(type, value) {
+    switch (type) {
+        case "null":
+            return value === null;
+        case "boolean":
+            return typeof value === "boolean";
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "string":
+            return typeof value === "string";
+        default:
+            return true;
+    }
+}
+export function unicodeLength(value) {
+    return [...value].length;
+}
+export function isMultipleOf(value, divisor) {
+    if (divisor === 0) {
+        return false;
+    }
+    const quotient = value / divisor;
+    return (Math.abs(quotient - Math.round(quotient)) <=
+        Number.EPSILON * Math.max(1, Math.abs(quotient)) * 4);
+}

package/node_modules/toolcraft-schema/dist/validate.d.ts

@@ -5,6 +5,7 @@ export type ValidationIssue = {
     expected: string;
     received: string;
     message: string;
+    keyword?: string;
 };
 export type ValidationResult<T> = {
     ok: true;

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.115",
+  "version": "0.0.117",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "test": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
-    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src",
     "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
   },
   "files": [

package/node_modules/uri-template/AUTHORS

@@ -0,0 +1,2 @@
+Stephen Sugden <me@stephensugden.com> (http://stephensugden.com)
+Andrei Neculau <andrei.neculau@gmail.com> (http://andreineculau.com)

package/node_modules/uri-template/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Stephen Sugden
+
+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.

package/node_modules/uri-template/README.md

@@ -0,0 +1,34 @@
+# URI Template
+
+[![Node.js CI](https://github.com/grncdr/uri-template/actions/workflows/nodejs.yml/badge.svg)](https://github.com/grncdr/uri-template/actions/workflows/nodejs.yml)
+
+This is a node.js implementation of the URI template draft standard
+defined at http://tools.ietf.org/html/rfc6570
+
+## Example
+
+```javascript
+var parser = require("uri-template");
+
+var tpl = parser.parse("/{year}/{month}/{day}{?orderBy,direction}");
+
+tpl.expand({ year: 2006, month: 6, day: 6 });
+// /2006/6/6
+
+tpl.expand({ year: 2006, month: 6, day: 6, orderBy: "size" });
+// /2006/6/6?orderBy=size
+
+tpl.expand({ year: 2006, month: 6, day: 6, orderBy: "time", direction: "asc" });
+// /2006/6/6?orderBy=time&direction=asc
+
+var queryTpl = parser.parse("/search{?q,otherParams*}");
+queryTpl.expand({
+  q: "Bigger office",
+  otherParams: { prefer: "Sterling's office", accept: "Crane's office" },
+});
+// /search?q=Bigger%20office&prefer=Sterling%27s%20office&accept=Crane%27s%20office
+```
+
+For more thorough coverage of the syntax, see the [RFC](https://datatracker.ietf.org/doc/html/rfc6570).
+
+## 

package/node_modules/uri-template/dist/ast.d.ts

@@ -0,0 +1,28 @@
+export interface Template {
+    type: "template";
+    parts: (Literal | Expression)[];
+}
+export interface Literal {
+    type: "literal";
+    value: string;
+}
+export interface Expression {
+    type: "expression";
+    operator: Operator;
+    variables: Variable[];
+}
+export declare type Operator = "/" | ";" | "." | "?" | "&" | "+" | "#" | "";
+export interface Variable {
+    type: "variable";
+    name: string;
+    modifier?: SubstrModifier | ExplodeModifier;
+    extension?: string;
+}
+export interface ExplodeModifier {
+    type: "explode";
+}
+export interface SubstrModifier {
+    type: "substr";
+    length: number;
+}
+export declare function toString(node: Template | Literal | Expression | Variable): string;

package/node_modules/uri-template/dist/ast.js

@@ -0,0 +1,27 @@
+"use strict";
+exports.__esModule = true;
+exports.toString = void 0;
+function toString(node) {
+    var _a, _b;
+    switch (node.type) {
+        case "template":
+            return node.parts.map(toString).join("");
+        case "literal":
+            return node.value;
+        case "expression":
+            return "{" + node.operator + node.variables.map(toString).join(",") + "}";
+        case "variable":
+            var out = node.name;
+            if (((_a = node.modifier) === null || _a === void 0 ? void 0 : _a.type) == "explode") {
+                out += "*";
+            }
+            else if (((_b = node.modifier) === null || _b === void 0 ? void 0 : _b.type) == "substr") {
+                out += ":" + node.modifier.length;
+            }
+            if (node.extension) {
+                out += "(" + node.extension + ")";
+            }
+            return out;
+    }
+}
+exports.toString = toString;

package/node_modules/uri-template/dist/expander.d.ts

@@ -0,0 +1,3 @@
+import { Template, Expression } from "./ast";
+export declare function expandTemplate(ast: Template, values: Record<string, unknown>): string;
+export declare function expandExpression(expression: Expression, values: Record<string, unknown>): string;

package/node_modules/uri-template/dist/expander.js

@@ -0,0 +1,165 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.expandExpression = exports.expandTemplate = void 0;
+var pct_encode_1 = __importDefault(require("pct-encode"));
+var encoders = {
+    UrlSafe: (0, pct_encode_1["default"])(/[^\w~.-]/g),
+    Restricted: (0, pct_encode_1["default"])(/[^\w.~:\/\?#\[\]@!\$&'()*+,;=%-]|%(?!\d\d)/g)
+};
+function expandTemplate(ast, values) {
+    var strings = ast.parts.map(function (part) {
+        switch (part.type) {
+            case "literal":
+                return part.value;
+            case "expression":
+                return expandExpression(part, values);
+        }
+    });
+    return strings.join("");
+}
+exports.expandTemplate = expandTemplate;
+var defaults = {
+    first: "",
+    sep: ",",
+    empty: "",
+    encode: encoders.UrlSafe,
+    named: false
+};
+var OperatorConfigs = {
+    "": __assign({}, defaults),
+    "+": __assign(__assign({}, defaults), { encode: encoders.Restricted }),
+    "#": __assign(__assign({}, defaults), { encode: encoders.Restricted, first: "#", empty: "#" }),
+    "/": __assign(__assign({}, defaults), { first: "/", sep: "/" }),
+    ".": __assign(__assign({}, defaults), { first: ".", sep: ".", empty: "." }),
+    ";": __assign(__assign({}, defaults), { first: ";", sep: ";", named: true }),
+    "?": __assign(__assign({}, defaults), { first: "?", sep: "&", empty: "=", named: true }),
+    "&": __assign(__assign({}, defaults), { first: "&", sep: "&", empty: "=", named: true })
+};
+function expandExpression(expression, values) {
+    var config = OperatorConfigs[expression.operator];
+    var strings = [];
+    expression.variables.forEach(function (variable) {
+        var value = values[variable.name];
+        if (!present(value))
+            return;
+        var string = expandVariable(variable, value, config);
+        strings.push(string || "");
+    });
+    if (strings.length === 0) {
+        return "";
+    }
+    var expanded = strings.join(config.sep);
+    if (expanded.length === 0) {
+        return config.empty;
+    }
+    return config.first + expanded;
+}
+exports.expandExpression = expandExpression;
+function expandVariable(variable, value, config) {
+    var _a;
+    if (value == null) {
+        throw new TypeError("tried to expand null value for variable " + variable.name + ", this is a bug in uri-template");
+    }
+    if (((_a = variable.modifier) === null || _a === void 0 ? void 0 : _a.type) === "explode") {
+        return expandValueExplode(variable, value, config);
+    }
+    else {
+        return expandValueSingle(variable, value, config);
+    }
+}
+function expandValueSingle(variable, value, _a) {
+    var _b, _c;
+    var empty = _a.empty, encode = _a.encode, named = _a.named;
+    if (typeof value === "object" && ((_b = variable.modifier) === null || _b === void 0 ? void 0 : _b.type) === "substr") {
+        throw new Error("Prefixed variables do not support lists/maps. Check " + variable.name);
+    }
+    var out;
+    if (Array.isArray(value)) {
+        out = value.map(encode).join(",");
+    }
+    else if (typeof value === "object") {
+        out = Object.entries(value)
+            .map(function (entry) { return entry.map(encode).join(","); })
+            .join(",");
+    }
+    else {
+        out = value.toString();
+        if (((_c = variable.modifier) === null || _c === void 0 ? void 0 : _c.type) === "substr") {
+            out = out.substring(0, variable.modifier.length);
+        }
+        out = encode(out);
+    }
+    if (named) {
+        if (out) {
+            out = variable.name + "=" + out;
+        }
+        else {
+            out = "" + variable.name + empty;
+        }
+    }
+    return out;
+}
+function expandValueExplode(variable, value, _a) {
+    var encode = _a.encode, named = _a.named, sep = _a.sep;
+    if (Array.isArray(value)) {
+        var items = value.map(encode);
+        if (named) {
+            items = items.map(function (item) { return variable.name + "=" + item; });
+        }
+        return items.join(sep);
+    }
+    else if (typeof value === "object") {
+        var pairs_1 = [];
+        Object.entries(value).forEach(function (_a) {
+            var k = _a[0], v = _a[1];
+            k = encode(k);
+            if (Array.isArray(v)) {
+                v.forEach(function (item) {
+                    pairs_1.push(k + "=" + encode(item));
+                });
+            }
+            else {
+                pairs_1.push(k + "=" + encode(v));
+            }
+        });
+        return pairs_1.join(sep);
+    }
+    else {
+        var s = value.toString();
+        return encode(s);
+    }
+}
+function present(v) {
+    switch (typeof v) {
+        case "undefined":
+            return false;
+        case "object":
+            if (v == null) {
+                return false;
+            }
+            if (Array.isArray(v)) {
+                return v.length > 0;
+            }
+            for (var k in v) {
+                if (v[k] != null)
+                    return true;
+            }
+            return false;
+        default:
+            return true;
+    }
+}

package/node_modules/uri-template/dist/grammar.d.ts

@@ -0,0 +1,13 @@
+declare function peg$SyntaxError(message: any, expected: any, found: any, location: any): Error;
+declare class peg$SyntaxError {
+    constructor(message: any, expected: any, found: any, location: any);
+    format(sources: any): string;
+}
+declare namespace peg$SyntaxError {
+    function buildMessage(expected: any, found: any): string;
+}
+declare function peg$parse(input: any, options: any): {
+    type: string;
+    parts: any;
+};
+export { peg$SyntaxError as SyntaxError, peg$parse as parse };