@versionzero/schema 1.0.0

package/src/value-processor/value-processor.js

@@ -0,0 +1,105 @@
+import { Executor } from '../executor/executor.js';
+import { SchemaLocation } from '../schema-location.js';
+
+/**
+ * @callback ValueProcessorFunction
+ * @param {any} value - The input value to be processed
+ * @param {any} target - The top-level target object or value which is being built, if known (do not mutate)
+ * @param {SchemaLocation} location - The path and schema of the value being processed within the schema hierarchy
+ * @param {object} options - Options passed to the handler containing this value processor
+ * @returns {any|Promise<any>} - Direct output value or a deferred promise if the value processor is asynchronous
+ */
+
+/** @typedef {`$${string}`} ValueProcessorKeyword */
+
+/** @typedef {ValueProcessorKeyword|{[keyword:ValueProcessorKeyword]:ValueProcessorSpec}} KeywordValueProcessorSpec */
+
+/** @typedef {ValueProcessorDefinition|ValueProcessorFunction|KeywordValueProcessorSpec|object|null|string|number|RegExp} ValueProcessorSpec */
+
+/** @typedef {ValueProcessor[]|{[param:string]:ValueProcessor}} ValueProcessorArgs */
+
+/**
+ * @callback ValueProcessorBuilder
+ * @param {ValueProcessorArgs} args
+ * @param {object} [options]
+ * @returns {ValueProcessor}
+ */
+
+// at what point does the parameter description become complex enough to warrant a schema definition?  :-P
+
+/**
+ * @typedef {object} ValueProcessorParameter
+ * @property {string} parameter
+ * @property {any} [default]
+ * @property {string} [type]
+ * @property {boolean} [required]
+ */
+
+/**
+ * @callback ValueProcessorDescriber
+ * @param {{[param:string]:ValueProcessor}|ValueProcessor[]|undefined} args
+ * @returns {string|undefined}
+ */
+
+/**
+ * @typedef {object} ValueProcessorDefinition
+ * @property {string} keyword
+ * @property {ValueProcessorFunction} [process]
+ * @property {ValueProcessorParameter[]} [parameters]
+ * @property {string} [description]
+ * @property {ValueProcessorBuilder} [build]
+ * @property {ValueProcessorDescriber} [describe]
+ */
+
+
+/**
+ * @augments {Executor<any>}
+ */
+export class ValueProcessor
+  extends Executor {
+  /** @type {string|undefined} */
+  #description;
+
+  /** @type {any} */
+  #spec;
+
+  /**
+   * @param {any} [spec]
+   * @param {string} [description]
+   */
+  constructor(spec, description) {
+    super();
+    this.#spec = spec;
+    this.#description = description;
+  }
+
+  get description() {
+    return this.#description;
+  }
+
+  set description(description) {
+    this.#description = description;
+  }
+
+  get spec() {
+    return this.#spec;
+  }
+
+  set spec(spec) {
+    this.#spec = spec;
+  }
+
+  /**
+   *
+   * @param {any} value
+   * @param {any} target
+   * @param {SchemaLocation} location
+   * @param {object} options
+   * @returns {any|Promise<any>}
+   */
+  execute(value, target, location, options) {
+    return value;
+  }
+}
+
+

package/types/compilation/handler-compilation.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {CompiledSchema} cs
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @param {object} transformOptions
+ * @returns {CompiledSchema}
+ * @this {SchemaCompiler}
+ */
+export function compileHandlers(this: SchemaCompiler, cs: CompiledSchema, _: any, location: SchemaLocation, transformOptions: object): CompiledSchema;
+import { CompiledSchema } from "../compiled-schema.js";
+import { SchemaLocation } from "../schema-location.js";
+import { SchemaCompiler } from "../schema-compiler.js";

package/types/compilation/metadata-compilation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {CompiledSchema} schema
+ * @returns {CompiledSchema}
+ */
+export function populateMetadata(schema: CompiledSchema): CompiledSchema;
+import { CompiledSchema } from "../compiled-schema.js";

package/types/compilation/schema-compilation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Convert a schema to a simple object form compatible with the SchemaCompiler SchemaSchema assumptions
+ *
+ * @param {any} schema
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @returns {import("../types.js").SchemaData}
+ * @this {SchemaCompiler}
+ */
+export function normalizeSchema(this: SchemaCompiler, schema: any, _: any, location: SchemaLocation): import("../types.js").SchemaData;
+/**
+ *
+ * @param {Schema|CompiledSchema} inputSchema
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @param {object} transformOptions
+ * @returns {CompiledSchema}
+ * @this {SchemaCompiler}
+ */
+export function transformSchema(this: SchemaCompiler, inputSchema: Schema | CompiledSchema, _: any, location: SchemaLocation, transformOptions: object): CompiledSchema;
+/**
+ * @param {CompiledSchema} schema
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @returns {CompiledSchema}
+ * @this {SchemaCompiler}
+ */
+export function validateSchema(this: SchemaCompiler, schema: CompiledSchema, _: any, location: SchemaLocation): CompiledSchema;
+import { SchemaLocation } from '../schema-location.js';
+import { SchemaCompiler } from '../schema-compiler.js';
+import { Schema } from '../schema.js';
+import { CompiledSchema } from '../compiled-schema.js';

package/types/compilation/selection-compilation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {CompiledSchema} inputSchema
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @returns {CompiledSchema}
+ */
+export function populateChildSelectorValues(inputSchema: CompiledSchema, _: any, location: SchemaLocation): CompiledSchema;
+import { CompiledSchema } from '../compiled-schema.js';
+import { SchemaLocation } from '../schema-location.js';

package/types/compilation/union-compilation.d.ts

@@ -0,0 +1,42 @@
+/** @import {ValueProcessorFunction} from '../value-processor/value-processor.js' */
+/**
+ * @param {CompiledSchema} inputSchema
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @returns {CompiledSchema}
+ * @this {SchemaCompiler}
+ */
+export function synthesizeKeyDiscrimination(this: SchemaCompiler, inputSchema: CompiledSchema, _: any, location: SchemaLocation): CompiledSchema;
+/**
+ * @param {CompiledSchema} inputSchema
+ * @param {any} _target
+ * @param {SchemaLocation} _location
+ * @param {object} options
+ * @returns {CompiledSchema}
+ * @this {SchemaCompiler}
+ */
+export function synthesizeAutoDiscrimination(this: SchemaCompiler, inputSchema: CompiledSchema, _target: any, _location: SchemaLocation, options: object): CompiledSchema;
+/**
+ * Collect values from union members onto the union schema itself.
+ * When all members define values, the union gets the full set (strict).
+ * When only some members define values, the union gets the known subset
+ * and `allowUnknownValues` is set so that `ensureAccepts` does not gate.
+ *
+ * Skips unions that already have values defined, or that have no members
+ * with values.
+ *
+ * @param {CompiledSchema} inputSchema
+ * @returns {CompiledSchema}
+ * @package
+ */
+export function synthesizeUnionValues(inputSchema: CompiledSchema): CompiledSchema;
+/**
+ * @param {CompiledSchema} inputSchema
+ * @returns {CompiledSchema}
+ */
+export function copyUnionOptions(inputSchema: CompiledSchema): CompiledSchema;
+export type SchemaSet = Set<CompiledSchema>;
+export type DiscriminatorPropertyMap = Map<string, SchemaSet>;
+import { CompiledSchema } from '../compiled-schema.js';
+import { SchemaLocation } from '../schema-location.js';
+import { SchemaCompiler } from '../schema-compiler.js';

package/types/compilation/values-compilation.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {CompiledSchema} cs
+ * @param {any} _
+ * @param {SchemaLocation} location
+ * @returns {CompiledSchema|Promise<CompiledSchema>}
+ * @this {SchemaCompiler}
+ */
+export function normalizeValues(this: SchemaCompiler, cs: CompiledSchema, _: any, location: SchemaLocation): CompiledSchema | Promise<CompiledSchema>;
+import { CompiledSchema } from '../compiled-schema.js';
+import { SchemaLocation } from '../schema-location.js';
+import { SchemaCompiler } from '../schema-compiler.js';