@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/v1/language/value/regexp/syntax.js

@@ -1,5 +1,6 @@
+import { limits } from '../../limits.js';
 import { parseIRegexp } from './ast.js';
-import { MAX_STATES, withinStateBudget } from './compile.js';
+import { withinStateBudget } from './compile.js';
 /** The refusal of one source, through the same AST and state count as compilation. */
 export function refuseIRegexp(source) {
     const expression = parseIRegexp(source);
@@ -13,5 +14,5 @@ export function isIRegexp(source) {
 }
 /** The authoring explanation of a `states` refusal of `subject` (`pattern`, `fullMatch`, ...). */
 export function stateBudgetMessage(subject) {
-    return `${subject} expands its counted repetitions into more than ${MAX_STATES} states, the I-Regexp implementation limit (RFC 9485 §8); nest fewer or smaller counts.`;
+    return `${subject} expands its counted repetitions into more than ${limits.regexp.maxStates} states, the I-Regexp implementation limit (RFC 9485 §8); nest fewer or smaller counts.`;
 }

package/dist/v1/language/value/syntax/keywords.d.ts

@@ -1,3 +1,3 @@
-export declare const SCHEMA_ARRAY_KEYWORDS: Set<string>;
-export declare const SCHEMA_MAP_KEYWORDS: Set<string>;
-export declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;
+export declare const SCHEMA_ARRAY_KEYWORDS: ReadonlySet<string>;
+export declare const SCHEMA_MAP_KEYWORDS: ReadonlySet<string>;
+export declare const SCHEMA_SINGLE_KEYWORDS: ReadonlySet<string>;

package/dist/v1/language/value/syntax/keywords.js

@@ -1,20 +1,4 @@
-export const SCHEMA_ARRAY_KEYWORDS = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
-export const SCHEMA_MAP_KEYWORDS = new Set([
-    '$defs',
-    'dependentSchemas',
-    'patternProperties',
-    'properties',
-]);
-export const SCHEMA_SINGLE_KEYWORDS = new Set([
-    'additionalProperties',
-    'contains',
-    'contentSchema',
-    'else',
-    'if',
-    'items',
-    'not',
-    'propertyNames',
-    'then',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-]);
+import { SUBSCHEMA_KEYWORDS } from '../profile/vocabulary.js';
+export const SCHEMA_ARRAY_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.array);
+export const SCHEMA_MAP_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.map);
+export const SCHEMA_SINGLE_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.single);

package/dist/v1/language/value/syntax/node-path/validate.js

@@ -29,11 +29,10 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
             location.schema.$ref !== GRAPH_NODE_PATH_SCHEMA_ID) {
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${pointer}${location.pointer}`, `A Path field schema contains exactly $ref ${GRAPH_NODE_PATH_SCHEMA_ID} and x-astrale-path.`, GRAPH_NODE_PATH_SCHEMA_ID));
         }
+        // The dialect refuses an annotation that is not an object, at every location.
         const annotation = location.schema['x-astrale-path'];
-        if (!isJsonObject(annotation)) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path must be a closed annotation object.'));
+        if (!isJsonObject(annotation))
             return;
-        }
         if (!hasExactKeys(annotation, ['target', 'cardinality', 'accepts'])) {
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path contains exactly target, cardinality, and accepts.'));
         }

package/dist/v1/language/value/syntax/pointer.d.ts

@@ -1,3 +1,5 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export declare function escapePointerToken(token: string): string;
 export declare function appendPointer(pointer: string, token: string | number): string;
 export declare function parseJsonPointerFragment(fragment: string): readonly string[] | undefined;
 export declare function tokensToPointer(tokens: readonly string[]): string;

package/dist/v1/language/value/syntax/pointer.js

@@ -1,6 +1,9 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export function escapePointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 export function appendPointer(pointer, token) {
-    const encoded = String(token).replaceAll('~', '~0').replaceAll('/', '~1');
-    return `${pointer}/${encoded}`;
+    return `${pointer}/${escapePointerToken(String(token))}`;
 }
 export function parseJsonPointerFragment(fragment) {
     if (!fragment.startsWith('#'))

package/dist/v1/language/value/syntax/walk.d.ts

@@ -6,5 +6,7 @@ export interface SchemaLocation {
     readonly parentKeyword?: string;
 }
 export declare function walkSchema(schema: JsonSchema, visit: (location: SchemaLocation) => void, pointer?: string): void;
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export declare function forEachSubschema(keyword: string, value: unknown, pointer: string, visit: (schema: JsonSchema, pointer: string) => void): void;
 export declare function collectSchemaPointers(schema: JsonSchema): ReadonlySet<string>;
 export declare function isJsonSchema(value: unknown): value is JsonSchema;

package/dist/v1/language/value/syntax/walk.js

@@ -14,26 +14,7 @@ export function walkSchema(schema, visit, pointer = '') {
             if (!isJsonObject(current))
                 return;
             for (const [keyword, value] of Object.entries(current)) {
-                const keywordPointer = appendPointer(currentPointer, keyword);
-                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-                    walk(value, keywordPointer, depth + 1, keyword);
-                    continue;
-                }
-                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-                    value.forEach((entry, index) => {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, index), depth + 1, keyword);
-                        }
-                    });
-                    continue;
-                }
-                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
-                    for (const [name, entry] of Object.entries(value)) {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, name), depth + 1, keyword);
-                        }
-                    }
-                }
+                forEachSubschema(keyword, value, appendPointer(currentPointer, keyword), (entry, at) => walk(entry, at, depth + 1, keyword));
             }
         }
         finally {
@@ -43,6 +24,24 @@ export function walkSchema(schema, visit, pointer = '') {
     }
     walk(schema, pointer, 0);
 }
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export function forEachSubschema(keyword, value, pointer, visit) {
+    if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+        visit(value, pointer);
+    }
+    else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        value.forEach((entry, index) => {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, index));
+        });
+    }
+    else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+        for (const [name, entry] of Object.entries(value)) {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, name));
+        }
+    }
+}
 export function collectSchemaPointers(schema) {
     const pointers = new Set();
     walkSchema(schema, ({ pointer }) => pointers.add(pointer));