@jarenjs/validate 0.8.4 → 0.9.2

package/dist/types/number.d.ts

@@ -0,0 +1 @@
+export declare function compileNumberBasic(schemaObj: any, jsonSchema: any): ((data: any, dataPath: any) => any) | undefined;

package/dist/types/object.d.ts

@@ -0,0 +1,3 @@
+export declare function compileObjectPrimitives(schemaObj: any, jsonSchema: any): ((data: any, dataPath: any, dataRoot: any, dataKeys: any) => any) | undefined;
+export declare function compileObjectChildren(schemaObj: any, jsonSchema: any): ((data: any, dataPath: any, dataRoot: any, dataKeys: any) => boolean) | undefined;
+export declare function compileObjectSchema(schemaObj: any, jsonSchema: any): ((data: any, dataPath: any, dataRoot: any) => any) | undefined;

package/dist/types/query-keyword.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Compile the '$query' keyword of a schema into a validator.
+ *
+ * The query document compiles with a `compileTypeTest` hook backed by the
+ * owning `JarenValidator` instance (threaded through `ValidationRoot`), so
+ * schema literals inside the query (`$valid`/`$assert`/`$as`) may `$ref`
+ * schemas registered on that instance with `addSchema`. Malformed query
+ * documents (`JQ0xxx`) and externals other than `root`/`path` throw here,
+ * at schema compile time. At validation time the query never throws:
+ * a `JsonQueryRuntimeError` (`JQ2xxx` - a data-shaped failure such as the
+ * EBV of a multi-item result or arithmetic on a non-number) reports as a
+ * validation failure whose error params carry the `code` and the query
+ * `docPath`.
+ *
+ * @param {object} schemaObj - The validation object
+ * @param {object} jsonSchema - The JSON schema containing the '$query' keyword
+ * @returns {function|undefined} The compiled validator function or undefined
+ */
+export declare function compileQuerySchema(schemaObj: object, jsonSchema: object): Function | undefined;

package/dist/types/query.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Create a `compileTypeTest` hook for `compileJsonQuery` (see
+ * `@jarenjs/json/query`), backed by a `JarenValidator`.
+ *
+ * The hook compiles each schema literal with the validator and returns
+ * its boolean-mode validation function - errors off, the fast path of
+ * this package's architecture. Schema compile failures (an invalid
+ * schema literal, an unresolvable `$ref`) propagate as plain errors; the
+ * query engine wraps them into `JsonQueryCompileError` `JQ0009` with the
+ * operator's document pointer.
+ *
+ * @param {object | (() => object)} [validator] - a `JarenValidator`
+ *   instance to compile with, or a zero-argument factory producing one.
+ *   Supply an instance with registered schemas (`addSchema`) so `$ref`s
+ *   in query schema literals resolve against them. Omitted, a fresh
+ *   default (boolean-mode) instance is created.
+ * @returns {(schemaJson: any, docPath: string) => ((value: any) => boolean)}
+ *   a hook suitable for `compileJsonQuery(doc, { compileTypeTest })`
+ * @example
+ * import { compileJsonQuery } from '@jarenjs/json/query';
+ * import { createTypeTestCompiler } from '@jarenjs/validate/query';
+ *
+ * const query = compileJsonQuery({
+ *   "$for": { "b": "$.store.book[*]" },
+ *   "$as": { "b": { "type": "object", "required": ["price"] } },
+ *   "$return": "$b.title"
+ * }, { compileTypeTest: createTypeTestCompiler() });
+ */
+export declare function createTypeTestCompiler(validator?: object | (() => object)): (schemaJson: any, docPath: string) => ((value: any) => boolean);

package/dist/types/schema.d.ts

@@ -0,0 +1 @@
+export declare function compileSchemaObject(schemaObj: any, jsonSchema: any): any;

package/dist/types/string.d.ts

@@ -0,0 +1 @@
+export declare function compileStringBasic(schemaObj: any, jsonSchema: any): ((data: any, dataPath: any) => any) | undefined;

package/dist/types/tools.d.ts

@@ -0,0 +1,51 @@
+import { isBooleanType } from '@jarenjs/core';
+import { isRegExpType } from '@jarenjs/core/string';
+export declare function isBoolOrObjectClass(obj: any): boolean;
+/**
+ * getBoolOrObjectClass
+ * extract the data of first parameter if data is boolean or object type otherwise return default
+ * @param {any} obj any data data has to be tested on boolean or object type
+ * @param {boolean | object | undefined} def default return type if not boolean or object type
+ * @returns {boolean | undefined} return value when boolean or object otherwise def
+ */
+export declare function getBoolOrObjectClass(obj: any, def?: boolean | object | undefined): boolean | undefined;
+export declare function getArrayClassMinItems(obj: any, len?: number, def?: undefined): any;
+export declare function isOfSchemaType(schema: any, type: any): boolean;
+export declare function hasSchemaRef(schema: any): boolean;
+export declare function hasSchemaRecursiveRef(schema: any): boolean;
+export declare function hasSchemaDynamicRef(schema: any): boolean;
+export declare function createIsSchemaTypeHandler(type: any, isStrict?: boolean): typeof isBooleanType | typeof isRegExpType | undefined;
+/**
+ * Records which properties (string keys) and items (numeric indexes) of a
+ * data instance were successfully evaluated during validation, so that
+ * unevaluatedProperties/unevaluatedItems can be checked afterwards.
+ *
+ * Entries are (data reference, key) pairs appended in application order.
+ * Applicators that discard annotations (failed anyOf/oneOf branches, not,
+ * failed if) take a mark() before running and rollback(mark) afterwards.
+ * The numeric key -1 means "all items of this array were evaluated".
+ */
+export declare class EvalLog {
+    #private;
+    /** Clears the log; called at the start of each root validation. */
+    reset(): void;
+    /** @returns {number} The current log position */
+    mark(): number;
+    /** Discards all entries recorded after the given mark. */
+    rollback(mark: any): void;
+    /** Records that `key` of instance `data` was evaluated. */
+    add(data: any, key: any): void;
+    /** @returns {boolean} True when property `key` of `data` was evaluated at or after `from` */
+    hasKey(data: any, key: any, from: any): boolean;
+    /** @returns {boolean} True when item `index` of `data` was evaluated at or after `from` (-1 entries cover all items) */
+    hasItem(data: any, index: any, from: any): boolean;
+}
+export declare class ValidationResult {
+    match: boolean;
+    errors: number;
+    static undefThat(): ValidationResult;
+    constructor(match?: boolean, errors?: number);
+    addValid(valid?: boolean): this;
+    addMatch(valid?: boolean): this;
+    addResult(result?: ValidationResult): this;
+}

package/dist/types/traverse.d.ts

@@ -0,0 +1,32 @@
+export declare function encodeJsonPointerPath(path: any, key: any, index: any): string;
+export declare function decodeJsonPointerPath(path: any): any;
+declare class JsonPointerOptions {
+    anchorsGlobal: boolean;
+    anchorsAllowed: boolean;
+    skipErrors: boolean;
+    constructor(anchorsGlobal?: boolean, anchorsAllowed?: boolean, skipErrors?: boolean);
+}
+declare class JsonPointer {
+    id: any;
+    search: any;
+    leftUri: any;
+    fragment: any;
+    constructor(id: any, search: any, leftUri: any, fragment: any);
+}
+export declare function createJsonPointer(refUri: any, baseUri: any, opts?: JsonPointerOptions): JsonPointer;
+export declare function storeSchemaIdsInMap(schemas: any, baseUri: any, schema: any, opts?: JsonPointerOptions): any;
+export declare function resolveRefSchemaShallow(schemas: any, refUri: any, baseUri: any, opts?: JsonPointerOptions): {
+    id: any;
+    schema: any;
+};
+export declare function restoreSchemaRefsInMap(schemas: any, opts?: JsonPointerOptions): void;
+export declare class TraverseOptions extends JsonPointerOptions {
+    origin: string;
+    mergeSchemas: boolean;
+    constructor(origin?: string, mergeSchemas?: boolean, anchorsGlobal?: boolean, anchorsAllowed?: boolean, skipErrors?: boolean);
+}
+export declare function resolveRefSchemaDeep(schemas: any, baseUri: any, refschema: any, opts?: TraverseOptions): {
+    id: any;
+    schema: any;
+};
+export {};

package/dist/types/unevaluated.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wraps a compiled schema validator so unevaluatedProperties/unevaluatedItems
+ * run last, seeing every annotation produced on this instance by the schema's
+ * own keywords and its in-place applicators (allOf/anyOf/oneOf/if/$ref/...).
+ * Returns the validator unchanged when evaluation tracking is off or the
+ * schema has no unevaluated* keywords.
+ * @param {import('./index.js').ValidationObject} schemaObj
+ * @param {object} jsonSchema
+ * @param {function} validator - The compiled validator for all other keywords
+ * @returns {function} The wrapped (or original) validator
+ */
+export declare function wrapUnevaluated(schemaObj: import('./index.js').ValidationObject, jsonSchema: object, validator: Function): Function;

package/package.json

@@ -1,20 +1,42 @@
 {
   "name": "@jarenjs/validate",
   "private": false,
-  "version": "0.8.4",
+  "version": "0.9.2",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./src/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./query": {
+      "types": "./dist/types/query.d.ts",
+      "default": "./src/query.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
-    "dist"
+    "dist/types/",
+    "src/",
+    "ARCHITECTURE.md"
   ],
   "description": "Jaren is a JavaScript JSON Schema Validator",
   "author": "joham",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jklarenbeek/jarenjs.git",
+    "url": "git+https://github.com/jklarenbeek/jarenjs.git",
     "directory": "packages/validate"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "keywords": [
     "jaren",
     "json",
@@ -23,9 +45,12 @@
     "validator"
   ],
   "scripts": {
-    "build": "node esbuild.config.js"
+    "build": "node esbuild.config.js && npm run build:types",
+    "build:types": "tsc -p tsconfig.json",
+    "prepack": "npm run build:types"
   },
-  "devDependencies": {
-    "esbuild": "^0.23.1"
+  "dependencies": {
+    "@jarenjs/core": "^0.9.2",
+    "@jarenjs/json": "^0.9.2"
   }
 }