@astrale-os/kernel-dsl 0.1.5 → 0.2.0-beta.10

package/dist/v1/language/value/profile/canonicalize.js

@@ -0,0 +1,130 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareDefinitionRefs, compareUnicode } from '../../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
+const TYPE_ORDER = ['null', 'boolean', 'integer', 'number', 'string', 'array', 'object'];
+const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
+const encoder = new TextEncoder();
+/** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
+export function canonicalizeValueSchema(schema, context, registry) {
+    void registry;
+    return canonicalizeSchema(schema, true, context);
+}
+function canonicalizeSchema(schema, root, context) {
+    if (typeof schema === 'boolean')
+        return schema;
+    const result = {};
+    for (const keyword of Object.keys(schema).sort()) {
+        if (root && keyword === '$schema')
+            continue;
+        const value = schema[keyword];
+        if (keyword === 'required' && Array.isArray(value)) {
+            assertUnique(value, String, 'required');
+            result[keyword] = [...value].sort((left, right) => compareUnicode(String(left), String(right)));
+        }
+        else if (keyword === 'type' && Array.isArray(value)) {
+            assertUnique(value, String, 'type');
+            result[keyword] = [...value].sort((left, right) => (TYPE_RANK.get(String(left)) ?? Number.MAX_SAFE_INTEGER) -
+                (TYPE_RANK.get(String(right)) ?? Number.MAX_SAFE_INTEGER));
+        }
+        else if (keyword === 'enum' && Array.isArray(value)) {
+            const entries = value.map(canonicalizeJson);
+            assertUnique(entries, json.serialize, 'enum');
+            result[keyword] = entries.sort(compareCanonicalBytes);
+        }
+        else if (keyword === 'dependentRequired' && isJsonObject(value)) {
+            result[keyword] = canonicalizeDependentRequired(value);
+        }
+        else if (keyword === 'x-astrale-path' && isJsonObject(value)) {
+            result[keyword] = canonicalizePathAnnotation(value);
+        }
+        else if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+            result[keyword] = canonicalizeSchema(value, false, context);
+        }
+        else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false, context) : canonicalizeJson(entry));
+        }
+        else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+            const schemas = {};
+            for (const name of Object.keys(value).sort()) {
+                const entry = value[name];
+                schemas[name] = isJsonSchema(entry)
+                    ? canonicalizeSchema(entry, false, context)
+                    : canonicalizeJson(entry);
+            }
+            result[keyword] = schemas;
+        }
+        else {
+            result[keyword] = canonicalizeJson(value);
+        }
+    }
+    return result;
+}
+function canonicalizeDependentRequired(value) {
+    const result = {};
+    for (const name of Object.keys(value).sort()) {
+        const dependencies = value[name];
+        if (!Array.isArray(dependencies)) {
+            result[name] = canonicalizeJson(dependencies);
+            continue;
+        }
+        assertUnique(dependencies, String, `dependentRequired.${name}`);
+        result[name] = [...dependencies].sort((left, right) => compareUnicode(String(left), String(right)));
+    }
+    return result;
+}
+function canonicalizePathAnnotation(value) {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+        const entry = value[key];
+        if (key === 'accepts' && Array.isArray(entry)) {
+            const accepts = entry.map(canonicalizeJson);
+            assertUnique(accepts, json.serialize, 'x-astrale-path.accepts');
+            result[key] = accepts.sort((left, right) => compareDefinitionRefs(left, right));
+        }
+        else
+            result[key] = canonicalizeJson(entry);
+    }
+    return result;
+}
+function canonicalizeJson(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError('Cannot canonicalize a non-finite number.');
+        if (Object.is(value, -0))
+            throw new TypeError('Cannot canonicalize negative zero.');
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(canonicalizeJson);
+    if (!isJsonObject(value))
+        throw new TypeError('Cannot canonicalize a non-JSON value.');
+    const result = {};
+    for (const key of Object.keys(value).sort())
+        result[key] = canonicalizeJson(value[key]);
+    return result;
+}
+function compareCanonicalBytes(left, right) {
+    const a = encoder.encode(json.serialize(left));
+    const b = encoder.encode(json.serialize(right));
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}
+function assertUnique(values, keyOf, name) {
+    const keys = new Set();
+    for (const value of values) {
+        const key = keyOf(value);
+        if (keys.has(key))
+            throw new TypeError(`${name} contains a duplicate value.`);
+        keys.add(key);
+    }
+}
+function isJsonSchema(value) {
+    return typeof value === 'boolean' || isJsonObject(value);
+}

package/dist/v1/language/value/profile/json.validate.d.ts

@@ -0,0 +1,2 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];

package/dist/v1/language/value/profile/json.validate.js

@@ -0,0 +1,14 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { diagnostic } from '../../validation/diagnostic.js';
+export function validateCanonicalJsonDomain(value, pointer) {
+    try {
+        acceptJsonValue(value);
+        return [];
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            return [diagnostic('VS_NUMBER_DOMAIN', `${pointer}${error.pointer}`, error.message)];
+        }
+        return [diagnostic('VS_META_SCHEMA', pointer, 'Value is outside the JSON data model.')];
+    }
+}

package/dist/v1/language/value/profile/meta-schema.compiled.d.ts

@@ -0,0 +1,78 @@
+export declare const validate: typeof validate20;
+export default validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+declare namespace validate20 {
+    var evaluated: {
+        props: {
+            fullMatch: boolean;
+            "x-astrale-path": boolean;
+            definitions: boolean;
+            dependencies: boolean;
+            $recursiveAnchor: boolean;
+            $recursiveRef: boolean;
+            contentEncoding: boolean;
+            contentMediaType: boolean;
+            contentSchema: boolean;
+            format: boolean;
+            title: boolean;
+            description: boolean;
+            default: boolean;
+            deprecated: boolean;
+            readOnly: boolean;
+            writeOnly: boolean;
+            examples: boolean;
+            type: boolean;
+            const: boolean;
+            enum: boolean;
+            multipleOf: boolean;
+            maximum: boolean;
+            exclusiveMaximum: boolean;
+            minimum: boolean;
+            exclusiveMinimum: boolean;
+            maxLength: boolean;
+            minLength: boolean;
+            pattern: boolean;
+            maxItems: boolean;
+            minItems: boolean;
+            uniqueItems: boolean;
+            maxContains: boolean;
+            minContains: boolean;
+            maxProperties: boolean;
+            minProperties: boolean;
+            required: boolean;
+            dependentRequired: boolean;
+            unevaluatedItems: boolean;
+            unevaluatedProperties: boolean;
+            prefixItems: boolean;
+            items: boolean;
+            contains: boolean;
+            additionalProperties: boolean;
+            properties: boolean;
+            patternProperties: boolean;
+            dependentSchemas: boolean;
+            propertyNames: boolean;
+            if: boolean;
+            then: boolean;
+            else: boolean;
+            allOf: boolean;
+            anyOf: boolean;
+            oneOf: boolean;
+            not: boolean;
+            $id: boolean;
+            $schema: boolean;
+            $ref: boolean;
+            $anchor: boolean;
+            $dynamicRef: boolean;
+            $dynamicAnchor: boolean;
+            $vocabulary: boolean;
+            $comment: boolean;
+            $defs: boolean;
+        };
+        dynamicProps: boolean;
+        dynamicItems: boolean;
+    };
+}