@jetio/validator 1.0.0

package/dist/cli.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+'use strict';
+
+var path = require('path');
+var fs = require('fs/promises');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+const METASCHEMA_CONFIGS = {
+    "draft-06": {
+        main: "https://json-schema.org/draft-06/schema",
+        subSchemas: [],
+    },
+    "draft-07": {
+        main: "https://json-schema.org/draft-07/schema",
+        subSchemas: [],
+    },
+    "draft/2019-09": {
+        main: "https://json-schema.org/draft/2019-09/schema",
+        subSchemas: [
+            "https://json-schema.org/draft/2019-09/meta/core",
+            "https://json-schema.org/draft/2019-09/meta/applicator",
+            "https://json-schema.org/draft/2019-09/meta/validation",
+            "https://json-schema.org/draft/2019-09/meta/meta-data",
+            "https://json-schema.org/draft/2019-09/meta/format",
+            "https://json-schema.org/draft/2019-09/meta/content",
+        ],
+    },
+    "draft/2020-12": {
+        main: "https://json-schema.org/draft/2020-12/schema",
+        subSchemas: [
+            "https://json-schema.org/draft/2020-12/meta/core",
+            "https://json-schema.org/draft/2020-12/meta/applicator",
+            "https://json-schema.org/draft/2020-12/meta/unevaluated",
+            "https://json-schema.org/draft/2020-12/meta/validation",
+            "https://json-schema.org/draft/2020-12/meta/meta-data",
+            "https://json-schema.org/draft/2020-12/meta/format-annotation",
+            "https://json-schema.org/draft/2020-12/meta/content",
+        ],
+    },
+};
+async function fetchSchema(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+async function loadSingleVersion(version, baseOutputDir = "./meta-schemas") {
+    const config = METASCHEMA_CONFIGS[version];
+    const outputDir = path__namespace.join(baseOutputDir, version);
+    await fs__namespace.mkdir(outputDir, { recursive: true });
+    const mainSchema = await fetchSchema(config.main);
+    const strippedMain = mainSchema;
+    const mainFile = path__namespace.join(outputDir, "schema.json");
+    await fs__namespace.writeFile(mainFile, JSON.stringify(strippedMain, null, 2));
+    console.log(`  ✓ ${mainFile}`);
+    for (const subUrl of config.subSchemas) {
+        const subSchema = await fetchSchema(subUrl);
+        const strippedSub = subSchema;
+        const metaDir = path__namespace.join(outputDir, "meta");
+        await fs__namespace.mkdir(metaDir, { recursive: true });
+        const filename = subUrl.split("/meta/")[1] + ".json";
+        const filepath = path__namespace.join(metaDir, filename);
+        await fs__namespace.writeFile(filepath, JSON.stringify(strippedSub, null, 2));
+        console.log(`  ✓ ${filepath}`);
+    }
+    console.log(`✓ Saved ${version} to ${outputDir}\n`);
+}
+async function parseExistingLoader(loaderPath) {
+    try {
+        const content = await fs__namespace.readFile(loaderPath, "utf-8");
+        const existingVersions = new Set();
+        for (const version of Object.keys(METASCHEMA_CONFIGS)) {
+            const funcName = "load" +
+                version.replace(/^draft[-\/]/, "Draft").replace(/[-\/\.]/g, "");
+            if (content.includes(`function ${funcName}(`)) {
+                existingVersions.add(version);
+            }
+        }
+        return existingVersions.size > 0 ? existingVersions : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function generateLoaderFiles(outputDir, loadedVersions) {
+    const loaderJsPath = path__namespace.join(outputDir, "loader.js");
+    const loaderDtsPath = path__namespace.join(outputDir, "loader.d.ts");
+    const existingVersions = await parseExistingLoader(loaderJsPath);
+    const allVersions = new Set([...(existingVersions || []), ...loadedVersions]);
+    let jsImports = "";
+    let jsLoadFunctions = "";
+    let dtsExports = "";
+    const functionNames = [];
+    for (const version of allVersions) {
+        const config = METASCHEMA_CONFIGS[version];
+        const funcName = "load" + version.replace(/^draft[-\/]/, "Draft").replace(/[-\/\.]/g, "");
+        functionNames.push(funcName);
+        const mainImportName = `schema_${version.replace(/[-\/\.]/g, "_")}`;
+        jsImports += `const ${mainImportName} = require('./${version}/schema.json');\n`;
+        const subImports = [];
+        for (const subUrl of config.subSchemas) {
+            const filename = subUrl.split("/meta/")[1];
+            const subImportName = `schema_${version.replace(/[-\/\.]/g, "_")}_${filename.replace(/[-\/\.]/g, "_")}`;
+            jsImports += `const ${subImportName} = require('./${version}/meta/${filename}.json');\n`;
+            subImports.push({ name: subImportName, url: subUrl });
+        }
+        jsImports += "\n";
+        jsLoadFunctions += `function ${funcName}(jetValidator) {
+  jetValidator.addMetaSchema(${mainImportName}, '${config.main}');
+  jetValidator.addMetaSchema(${mainImportName}, '${version}');
+  
+`;
+        for (const sub of subImports) {
+            jsLoadFunctions += `  jetValidator.addMetaSchema(${sub.name}, '${sub.url}');\n`;
+            const relativePath = sub.url.split("/meta/")[1];
+            if (relativePath) {
+                jsLoadFunctions += `  jetValidator.addMetaSchema(${sub.name}, '${version}/meta/${relativePath}');\n`;
+            }
+        }
+        jsLoadFunctions += `}\n\n`;
+        dtsExports += `export function ${funcName}(jetValidator: any): void;\n`;
+    }
+    jsLoadFunctions += `function loadAllMetaSchemas(jetValidator) {
+`;
+    for (const funcName of functionNames) {
+        jsLoadFunctions += `  ${funcName}(jetValidator);\n`;
+    }
+    jsLoadFunctions += `}\n\n`;
+    dtsExports += `export function loadAllMetaSchemas(jetValidator: any): void;\n`;
+    const jsExports = functionNames.map((name) => name).join(",\n  ");
+    const jsContent = `/**
+ * Auto-generated meta-schema loader
+ * Generated by: jetvalidator-meta load
+ * 
+ * Usage:
+ *   const { loadDraft07, loadAllMetaSchemas } = require('./loader');
+ *   
+ *   const jetValidator = new JetValidator();
+ *   loadDraft07(jetValidator); // Load specific version
+ *   // OR
+ *   loadAllMetaSchemas(jetValidator); // Load all versions
+ */
+
+${jsImports}
+${jsLoadFunctions}
+module.exports = {
+  ${jsExports},
+  loadAllMetaSchemas
+};
+`;
+    const dtsContent = `/**
+ * Auto-generated meta-schema loader
+ * Generated by: jetvalidator-meta load
+ */
+
+${dtsExports}`;
+    await fs__namespace.writeFile(loaderJsPath, jsContent);
+    await fs__namespace.writeFile(loaderDtsPath, dtsContent);
+    const isAppending = existingVersions && existingVersions.size > 0;
+    console.log(`\n✓ ${isAppending ? "Updated" : "Generated"}: ${loaderJsPath}`);
+    console.log(`✓ ${isAppending ? "Updated" : "Generated"}: ${loaderDtsPath}`);
+    if (isAppending) {
+        console.log(`  (Merged with ${existingVersions.size} existing version(s))`);
+    }
+    console.log(`\nUsage (CommonJS):`);
+    console.log(`  const { ${functionNames.join(", ")}, loadAllMetaSchemas } = require('${outputDir}/loader');\n`);
+    console.log(`Usage (ES Modules):`);
+    console.log(`  import { ${functionNames.join(", ")}, loadAllMetaSchemas } from '${outputDir}/loader';\n`);
+}
+async function loadMetaschema(version, outputDir = "./meta-schemas") {
+    const loadedVersions = new Set();
+    if (version === "all") {
+        const versions = Object.keys(METASCHEMA_CONFIGS);
+        for (const v of versions) {
+            await loadSingleVersion(v, outputDir);
+            loadedVersions.add(v);
+        }
+    }
+    else {
+        await loadSingleVersion(version, outputDir);
+        loadedVersions.add(version);
+    }
+    await generateLoaderFiles(outputDir, loadedVersions);
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === "load") {
+        args.shift(); // remove 'load'
+    }
+    const version = args[0] || "all";
+    const outputDir = args[1] || "./meta-schemas";
+    console.log(`Loading meta-schema: ${version}`);
+    console.log(`Output directory: ${path__namespace.resolve(outputDir)}`);
+    await loadMetaschema(version, outputDir);
+    console.log("✓ Meta-schemas downloaded and saved");
+}
+main();

package/dist/compileSchema.d.ts

@@ -0,0 +1,148 @@
+import { ArraySchema, ObjectSchema, SchemaDefinition } from "./types/schema";
+import { ValidatorOptions } from "./types/validation";
+import { CompiledValidateFunction } from "./types/keywords";
+import { JetValidator } from "./jet-validator";
+export type Extra = {
+    before: string;
+    after: string;
+    refAfter?: string;
+};
+interface ErrorInfo {
+    keyword: string;
+    value: string;
+    message: string;
+    expected?: string;
+    dataPath?: string;
+    schemaPath?: string;
+}
+/**
+ * PathContext: Lightweight object containing only path strings.
+ * Created on every recursion but only contains 4 strings (cheap to allocate).
+ *
+ * TrackingState: Mutable state for unevaluated* tracking.
+ * Mutated in place when possible to avoid allocations.
+ * Only spread when crossing schema boundaries that introduce new tracking requirements.
+ *
+ * this.options: Immutable config stored in class instance.
+ * Never passed as parameter - accessed via this.options.
+ *
+ * Performance: This design reduces allocations by ~60% compared to
+ * spreading a single 13-property object on every recursion.
+ */
+interface PathContext {
+    schema: string;
+    data: string;
+    $data: string;
+    alt?: string;
+    alt2?: string;
+}
+interface TrackingState {
+    isSubschema?: boolean;
+    parentHasUnevaluatedProperties?: boolean;
+    hasOwnUnevaluatedProperties?: boolean;
+    shouldTrackEvaluatedProperties?: boolean;
+    parentHasUnevaluatedItems?: boolean;
+    hasOwnUnevaluatedItems?: boolean;
+    shouldTrackEvaluatedItems?: boolean;
+    parentUnevaluatedPropVar?: string;
+    unevaluatedPropVar?: string;
+    parentUnevaluatedItemVar?: string;
+    unevaluatedItemVar?: string;
+    unEvaluatedPropertiesSetVar?: string;
+    unEvaluatedItemsSetVar?: string;
+}
+export declare class Compiler {
+    private refables;
+    private ranRefables;
+    private refCall;
+    private schema;
+    private options;
+    private errorVariableDeclared;
+    private errorVariable;
+    private compiledKeywords;
+    regexCache: Map<string, string>;
+    private validateKeywords;
+    private allKeywords;
+    private jetValidator;
+    private notLogic;
+    private noreturn;
+    private neutralError;
+    private compileContext;
+    private standAlone;
+    private hasCompileKeyword;
+    needslen_of: boolean;
+    needsStringify: boolean;
+    needsDeepEqual: boolean;
+    mainFunctionName: string;
+    hoistedFunctions: string[];
+    constructor(refables: any[] | undefined, schema: SchemaDefinition | boolean, options: Partial<ValidatorOptions>, jetValidator: JetValidator, allKeywords: Set<string>, compileContext: {
+        hasUnevaluatedProperties: boolean;
+        hasUnevaluatedItems: boolean;
+        hasRootReference: boolean;
+        referencedFunctions: string[];
+        uses$Data: boolean;
+    }, standalone?: boolean);
+    getCompiledKeywords(): {
+        compiledKeywords: Map<string, CompiledValidateFunction>;
+        validateKeywords: Set<string>;
+        hasCompileKeyword: boolean;
+    };
+    private createSubschemaOptions;
+    private handleCustomKeywords;
+    private handleCodeKeyword;
+    private handleCompileKeyword;
+    private handleValidateKeyword;
+    compileSchema(rootSchema: SchemaDefinition | boolean, pathContext?: PathContext, trackingState?: TrackingState, accessPattern?: string, extra?: Extra, inlined?: boolean, first?: boolean): string;
+    initializeDefault(src: string[], schema: SchemaDefinition, varName: string, accessPattern: string, inlined: boolean): void;
+    private initializePropertyTracking;
+    private initializeItemTracking;
+    inilineRefFunction(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    initializeRefables(pathContext: PathContext): void;
+    initializeSchemaRefables(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleReference(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): string | void;
+    private buildRefCallArgs;
+    handleLogicalOperators(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleNotOperator(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleAnyOfOperator(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleOneOfOperator(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleAllOfOperator(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleConditionalLogic(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleElseIfConditions(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, previousIfValid: string, elseIfVariableArray: string[]): any;
+    handleElseIfThen(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, elseIfVariableArray: any, extra: Extra): void;
+    handleTypeValidation(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    private generateTypeCheck;
+    handlePrimitive(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    private handleConst;
+    private handleMinLength;
+    private handleMaxLength;
+    private handleMinimum;
+    private handleMaximum;
+    private handleExclusiveMinimum;
+    private handleExclusiveMaximum;
+    handleMultipleOf(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    handlePattern(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleEnum(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleFormat(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleObject(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, condition: boolean, extra: Extra): void;
+    handleRequiredProperties(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    collectAllAllowedProperties(schema: SchemaDefinition | boolean): {
+        allowedProperties: Set<string>;
+        patternProperties: string[];
+    };
+    handlePatternProperties(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleAdditionalProperties(src: string[], schema: SchemaDefinition, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handlePropertyConstraints(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, extra: Extra): void;
+    handlePropertyNames(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleDependentSchemas(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    private handleRequiredFields;
+    private handleDependentSchema;
+    handleObjectProperties(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, propertyKeys: string[], extra: Extra): void;
+    handleUnevaluatedProperties(src: string[], schema: ObjectSchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleArray(src: string[], schema: ArraySchema, varName: string, pathContext: PathContext, trackingState: TrackingState, condition: boolean, extra: Extra): void;
+    handleArrayConstraints(src: string[], schema: ArraySchema, varName: string, pathContext: PathContext, extra: Extra): void;
+    handleArrayItems(src: string[], schema: ArraySchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleArrayContains(src: string[], schema: ArraySchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    handleUnevaluatedItems(src: string[], schema: ArraySchema, varName: string, pathContext: PathContext, trackingState: TrackingState, extra: Extra): void;
+    buildErrorReturn(pathContext: PathContext, error: ErrorInfo, spreads?: string): string;
+}
+export {};