@travetto/schema 7.0.0-rc.2 → 7.0.0-rc.4

package/README.md

@@ -293,11 +293,11 @@ export interface ValidationError {
   /**
    * Regular expression to match
    */
-  re?: string;
+  regex?: string;
   /**
    * Number to compare against
    */
-  n?: number | Date;
+  limit?: number | Date;
   /**
    * The type of the field
    */
@@ -322,7 +322,7 @@ This feature is meant to allow for simple Typescript types to be able to be back
 /**
  * Geometric Point as [number,number] with validation and binding support
  *
- * @concrete ./internal/types.ts#PointImplementation
+ * @concrete ./internal/types.ts#PointContract
  */
 export type Point = [number, number];
 ```
@@ -334,9 +334,9 @@ import { DataUtil } from '../data.ts';
 const InvalidSymbol = Symbol();
 
 /**
- * Point Implementation
+ * Point Contract
  */
-export class PointImplementation {
+export class PointContract {
 
   /**
    * Validate we have an actual point
@@ -359,7 +359,7 @@ export class PointImplementation {
   }
 }
 
-Object.defineProperty(PointImplementation, 'name', { value: 'Point' });
+Object.defineProperty(PointContract, 'name', { value: 'Point' });
 ```
 
 What you can see here is that the `Point` type is now backed by a class that supports:

package/__index__.ts

@@ -4,10 +4,9 @@ export * from './src/decorator/input.ts';
 export * from './src/decorator/schema.ts';
 export * from './src/decorator/method.ts';
 export * from './src/decorator/common.ts';
-export * from './src/service/changes.ts';
 export * from './src/service/types.ts';
 export * from './src/validate/messages.ts';
-export * from './src/validate/regexp.ts';
+export * from './src/validate/regex.ts';
 export * from './src/validate/validator.ts';
 export * from './src/validate/error.ts';
 export * from './src/validate/types.ts';
@@ -15,4 +14,5 @@ export * from './src/bind-util.ts';
 export * from './src/data.ts';
 export * from './src/name.ts';
 export * from './src/types.ts';
-export * from './src/service/registry-index.ts';
+export * from './src/service/registry-index.ts';
+export * from './src/service/registry-adapter.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "7.0.0-rc.2",
+  "version": "7.0.0-rc.4",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,10 +27,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^7.0.0-rc.2"
+    "@travetto/registry": "^7.0.0-rc.4"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.2"
+    "@travetto/transformer": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator/input.ts

@@ -1,6 +1,6 @@
 import { Any, Class, ClassInstance, getClass } from '@travetto/runtime';
 
-import { CommonRegExp } from '../validate/regexp.ts';
+import { CommonRegex } from '../validate/regex.ts';
 import { CONSTRUCTOR_PROPERTY, SchemaInputConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
@@ -76,53 +76,53 @@ export function LongText(): PropType<string | string[]> { return input({ specifi
 
 /**
  * Require the input to match a specific RegExp
- * @param re The regular expression to match against
+ * @param regex The regular expression to match against
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Match(re: RegExp, message?: string): PropType<string | string[]> { return input({ match: { re, message } }); }
+export function Match(regex: RegExp, message?: string): PropType<string | string[]> { return input({ match: { regex, message } }); }
 
 /**
  * The minimum length for the string or array
- * @param n The minimum length
+ * @param limit The minimum length
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MinLength(n: number, message?: string): PropType<string | unknown[]> {
-  return input({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) });
+export function MinLength(limit: number, message?: string): PropType<string | unknown[]> {
+  return input({ minlength: { limit, message }, ...(limit === 0 ? { required: { active: false } } : {}) });
 }
 
 /**
  * The maximum length for the string or array
- * @param n The maximum length
+ * @param limit The maximum length
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MaxLength(n: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { n, message } }); }
+export function MaxLength(limit: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { limit, message } }); }
 
 /**
  * The minimum value
- * @param n The minimum value
+ * @param limit The minimum value
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Min<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return input({ min: { n, message } });
+export function Min<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
+  return input({ min: { limit, message } });
 }
 
 /**
  * The maximum value
- * @param n The maximum value
+ * @param limit The maximum value
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Max<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return input({ max: { n, message } });
+export function Max<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
+  return input({ max: { limit, message } });
 }
 
 /**
@@ -131,7 +131,7 @@ export function Max<T extends number | Date>(n: T, message?: string): PropType<D
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegExp.email, message); }
+export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegex.email, message); }
 
 /**
  * Mark an input as an telephone number
@@ -139,7 +139,7 @@ export function Email(message?: string): PropType<string | string[]> { return Ma
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegExp.telephone, message); }
+export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegex.telephone, message); }
 
 /**
  * Mark an input as a url
@@ -147,7 +147,7 @@ export function Telephone(message?: string): PropType<string | string[]> { retur
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Url(message?: string): PropType<string | string[]> { return Match(CommonRegExp.url, message); }
+export function Url(message?: string): PropType<string | string[]> { return Match(CommonRegex.url, message); }
 
 /**
  * Determine the numeric precision of the value

package/src/internal/types.ts

@@ -3,9 +3,9 @@ import { DataUtil } from '../data.ts';
 const InvalidSymbol = Symbol();
 
 /**
- * Point Implementation
+ * Point Contract
  */
-export class PointImplementation {
+export class PointContract {
 
   /**
    * Validate we have an actual point
@@ -28,4 +28,4 @@ export class PointImplementation {
   }
 }
 
-Object.defineProperty(PointImplementation, 'name', { value: 'Point' });
+Object.defineProperty(PointContract, 'name', { value: 'Point' });

package/src/service/registry-adapter.ts

@@ -7,6 +7,8 @@ import {
   CONSTRUCTOR_PROPERTY
 } from './types';
 
+export type SchemaDiscriminatedInfo = Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>>;
+
 const classToDiscriminatedType = (cls: Class): string => cls.name
   .replace(/([A-Z])([A-Z][a-z])/g, (all, left, right) => `${left}_${right.toLowerCase()}`)
   .replace(/([a-z]|\b)([A-Z])/g, (all, left, right) => left ? `${left}_${right.toLowerCase()}` : right.toLowerCase())
@@ -69,6 +71,7 @@ function getConstructorConfig<T extends SchemaClassConfig>(base: Partial<T>, par
   const parentCons = parent?.methods?.[CONSTRUCTOR_PROPERTY];
   const baseCons = base.methods?.[CONSTRUCTOR_PROPERTY];
   return {
+    class: base.class!,
     parameters: [],
     validators: [],
     ...parentCons,
@@ -168,7 +171,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerField(field: string, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
     const classConfig = this.register({});
-    const config = classConfig.fields[field] ??= { name: field, owner: this.#cls, type: null! };
+    const config = classConfig.fields[field] ??= { name: field, class: this.#cls, type: null! };
     const combined = combineInputs(config, data);
     return combined;
   }
@@ -197,7 +200,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerMethod(method: string, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
     const classConfig = this.register();
-    const config = classConfig.methods[method] ??= { parameters: [], validators: [] };
+    const config = classConfig.methods[method] ??= { class: this.#cls, parameters: [], validators: [] };
     return combineMethods(config, data);
   }
 
@@ -213,7 +216,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerParameter(method: string, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
     const params = this.registerMethod(method, {}).parameters;
-    const config = params[idx] ??= { method, index: idx, owner: this.#cls, array: false, type: null! };
+    const config = params[idx] ??= { method, index: idx, class: this.#cls, array: false, type: null! };
     return combineInputs(config, data);
   }
 
@@ -305,8 +308,8 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   }
 
   /**
-  * Provides the prototype-derived descriptor for a property
-  */
+   * Provides the prototype-derived descriptor for a property
+   */
   getAccessorDescriptor(field: string): PropertyDescriptor {
     if (!this.#accessorDescriptors.has(field)) {
       let proto = this.#cls.prototype;
@@ -330,7 +333,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return value;
   }
 
-  getDiscriminatedConfig(): Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>> | undefined {
+  getDiscriminatedConfig(): SchemaDiscriminatedInfo | undefined {
     const { discriminatedField, discriminatedType, discriminatedBase } = this.#config;
     if (discriminatedType && discriminatedField) {
       return { discriminatedType, discriminatedField, discriminatedBase: !!discriminatedBase };

package/src/service/registry-index.ts

@@ -1,9 +1,8 @@
-import { ChangeEvent, RegistrationMethods, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castKey, castTo, Class, classConstruct, getParentClass, Util } from '@travetto/runtime';
+import { RegistrationMethods, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { AppError, castKey, castTo, Class, classConstruct, getParentClass } from '@travetto/runtime';
 
 import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
-import { SchemaRegistryAdapter } from './registry-adapter.ts';
-import { SchemaChangeListener } from './changes.ts';
+import { SchemaDiscriminatedInfo, SchemaRegistryAdapter } from './registry-adapter.ts';
 
 /**
  * Schema registry index for managing schema configurations across classes
@@ -20,7 +19,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.get(cls).get();
   }
 
-  static getDiscriminatedConfig<T>(cls: Class<T>): Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>> | undefined {
+  static getDiscriminatedConfig<T>(cls: Class<T>): SchemaDiscriminatedInfo | undefined {
     return this.#instance.store.get(cls).getDiscriminatedConfig();
   }
 
@@ -28,10 +27,6 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.has(cls);
   }
 
-  static getClassById(classId: string): Class {
-    return this.#instance.store.getClassById(classId);
-  }
-
   static getDiscriminatedTypes(cls: Class): string[] | undefined {
     return this.#instance.getDiscriminatedTypes(cls);
   }
@@ -68,6 +63,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
   #baseSchema = new Map<Class, Class>();
   #byDiscriminatedTypes = new Map<Class, Map<string, Class>>();
 
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
   /**
    * Register discriminated types for a class
    */
@@ -84,40 +81,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
     this.#byDiscriminatedTypes.get(base)!.set(config.discriminatedType, cls);
   }
 
-  #onChanged(event: ChangeEvent<Class> & { type: 'changed' }): void {
-    Util.queueMacroTask().then(() => {
-      SchemaChangeListener.emitFieldChanges({
-        type: 'changed',
-        current: this.getClassConfig(event.current),
-        previous: this.getClassConfig(event.previous)
-      });
-    });
-  }
-
-  #onRemoving(event: ChangeEvent<Class> & { type: 'removing' }): void {
-    SchemaChangeListener.clearSchemaDependency(event.previous);
-  }
-
-  #onAdded(event: ChangeEvent<Class> & { type: 'added' }): void {
-    Util.queueMacroTask().then(() => {
-      SchemaChangeListener.emitFieldChanges({
-        type: 'added',
-        current: this.getClassConfig(event.current)
-      });
-    });
-  }
-
-  process(events: ChangeEvent<Class>[]): void {
-    for (const event of events) {
-      if (event.type === 'changed') {
-        this.#onChanged(event);
-      } else if (event.type === 'removing') {
-        this.#onRemoving(event);
-      } else if (event.type === 'added') {
-        this.#onAdded(event);
-      }
-    }
-
+  beforeChangeSetComplete(): void {
     // Rebuild indices after every "process" batch
     this.#byDiscriminatedTypes.clear();
     for (const cls of this.store.getClasses()) {
@@ -174,25 +138,6 @@ export class SchemaRegistryIndex implements RegistryIndex {
     }
   }
 
-  /**
-   * Track changes to schemas, and track the dependent changes
-   * @param cls The root class of the hierarchy
-   * @param current The new class
-   * @param path The path within the object hierarchy
-   */
-  trackSchemaDependencies(cls: Class, current: Class = cls, path: SchemaFieldConfig[] = []): void {
-    const config = this.getClassConfig(current);
-
-    SchemaChangeListener.trackSchemaDependency(current, cls, path, this.getClassConfig(cls));
-
-    // Read children
-    for (const field of Object.values(config.fields)) {
-      if (SchemaRegistryIndex.has(field.type) && field.type !== cls) {
-        this.trackSchemaDependencies(cls, field.type, [...path, field]);
-      }
-    }
-  }
-
   /**
    * Visit fields recursively
    */

package/src/service/types.ts

@@ -36,6 +36,10 @@ export type SchemaBasicType = {
  * Basic schema configuration
  */
 export interface SchemaCoreConfig {
+  /**
+   * Schema class
+   */
+  class: Class;
   /**
    * Description
    */
@@ -90,10 +94,6 @@ export interface SchemaFieldMap {
  * Class configuration
  */
 export interface SchemaClassConfig extends SchemaCoreConfig {
-  /**
-   * Target class
-   */
-  class: Class;
   /**
    * List of all views
    */
@@ -144,10 +144,6 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
    * Key name for validation when dealing with complex types
    */
   view?: string;
-  /**
-   * Owner class
-   */
-  owner: Class;
   /**
    * List of aliases
    */
@@ -167,23 +163,23 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
    * Does the field expect a match
    */
-  match?: { re: RegExp, message?: string, template?: TemplateLiteral };
+  match?: { regex: RegExp, message?: string, template?: TemplateLiteral };
   /**
    * Minimum value configuration
    */
-  min?: { n: number | Date, message?: string };
+  min?: { limit: number | Date, message?: string };
   /**
    * Maximum value configuration
    */
-  max?: { n: number | Date, message?: string };
+  max?: { limit: number | Date, message?: string };
   /**
    * Minimum length configuration
    */
-  minlength?: { n: number, message?: string };
+  minlength?: { limit: number, message?: string };
   /**
    * Maximum length configuration
    */
-  maxlength?: { n: number, message?: string };
+  maxlength?: { limit: number, message?: string };
   /**
    * Enumerated values
    */

package/src/types.ts

@@ -3,6 +3,6 @@ export class UnknownType { }
 /**
  * Geometric Point as [number,number] with validation and binding support
  *
- * @concrete ./internal/types.ts#PointImplementation
+ * @concrete ./internal/types.ts#PointContract
  */
 export type Point = [number, number];

package/src/validate/messages.ts

@@ -5,14 +5,14 @@ export const Messages = new Map<string, string>(Object.entries({
   default: '{path} is not valid',
   type: '{path} is not a valid {type}',
   required: '{path} is required',
-  minlength: '{path} is not long enough ({n})',
-  maxlength: '{path} is too long ({n})',
-  match: '{path} should match {re}',
-  min: '{path} is less than ({n})',
-  max: '{path} is greater than ({n})',
-  telephone: '{path} is not a valid phone number',
-  url: '{path} is not a valid url',
-  simpleName: '{path} is not a proper name',
-  postalCode: '{path} is not a valid postal code',
-  email: '{path} is not a valid email address'
+  minlength: '{path} is not long enough ({limit})',
+  maxlength: '{path} is too long ({limit})',
+  match: '{path} should match {regex}',
+  min: '{path} is less than ({limit})',
+  max: '{path} is greater than ({limit})',
+  '[[:telephone:]]': '{path} is not a valid phone number',
+  '[[:url:]]': '{path} is not a valid url',
+  '[[:simpleName:]]': '{path} is not a proper name',
+  '[[:postalCode:]]': '{path} is not a valid postal code',
+  '[[:email:]]': '{path} is not a valid email address'
 }));

package/src/validate/regex.ts

@@ -0,0 +1,22 @@
+import { TypedObject } from '@travetto/runtime';
+
+/**
+ * List of common regular expressions for fields
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const [CommonRegex, CommonRegexToName] = (() => {
+  const regexToName = new Map<RegExp, string>();
+  const regexes = {
+    email: /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
+    telephone: /^(\+?\d{1,3}(\s*-?\s*|\s+))?((\(\d{3}\))|\d{3})(\s*|-|[.])(\d{3})(\s*|-|[.])(\d{4})(\s+(x|ext[.]?)\s*\d+)?$/,
+    url: /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/,
+    simpleName: /^([a-zA-Z\u0080-\u024F]{0,100}(?:. |-| |')){0,10}[a-zA-Z\u0080-\u024F]+$/,
+    postalCode: /^\d{5}(?:[-\s]\d{4})?$/
+  };
+  // Rebind regexes
+  for (const key of TypedObject.keys(regexes)) {
+    const name = `[[:${key}:]]`;
+    regexToName.set(regexes[key], name);
+  }
+  return [regexes, regexToName];
+})();

package/src/validate/types.ts

@@ -25,11 +25,11 @@ export interface ValidationError {
   /**
    * Regular expression to match
    */
-  re?: string;
+  regex?: string;
   /**
    * Number to compare against
    */
-  n?: number | Date;
+  limit?: number | Date;
   /**
    * The type of the field
    */
@@ -63,11 +63,11 @@ export interface ValidationResult {
   /**
    * Potential regular expression for the result
    */
-  re?: RegExp;
+  regex?: RegExp;
   /**
    * Number to compare against
    */
-  n?: number | Date;
+  limit?: number | Date;
 }
 
 type OrPromise<T> = T | Promise<T>;

package/src/validate/validator.ts

@@ -5,7 +5,7 @@ import { ValidationError, ValidationKindCore, ValidationResult } from './types.t
 import { Messages } from './messages.ts';
 import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
 import { DataUtil } from '../data.ts';
-import { CommonRegExpToName } from './regexp.ts';
+import { CommonRegexToName } from './regex.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
 /**
@@ -111,7 +111,7 @@ export class SchemaValidator {
       (input.type === Date ? Date.parse(value) : parseInt(value, 10)) :
       (value instanceof Date ? value.getTime() : value);
 
-    const boundary = (typeof config.n === 'number' ? config.n : config.n.getTime());
+    const boundary = (typeof config.limit === 'number' ? config.limit : config.limit.getTime());
     return key === 'min' ? parsed < boundary : parsed > boundary;
   }
 
@@ -144,15 +144,15 @@ export class SchemaValidator {
       }
     }
 
-    if (input.match && !input.match.re.test(`${value}`)) {
+    if (input.match && !input.match.regex.test(`${value}`)) {
       criteria.push(['match', input.match]);
     }
 
-    if (input.minlength && `${value}`.length < input.minlength.n) {
+    if (input.minlength && `${value}`.length < input.minlength.limit) {
       criteria.push(['minlength', input.minlength]);
     }
 
-    if (input.maxlength && `${value}`.length > input.maxlength.n) {
+    if (input.maxlength && `${value}`.length > input.maxlength.limit) {
       criteria.push(['maxlength', input.maxlength]);
     }
 
@@ -189,17 +189,17 @@ export class SchemaValidator {
         kind: result.kind,
         value: result.value,
         message: '',
-        re: CommonRegExpToName.get(result.re!) ?? result.re?.source ?? '',
+        regex: CommonRegexToName.get(result.regex!) ?? result.regex?.source ?? '',
         path,
         type: (typeof result.type === 'function' ? result.type.name : result.type)
       };
 
-      if (!error.re) {
-        delete error.re;
+      if (!error.regex) {
+        delete error.regex;
       }
 
       const msg = result.message ?? (
-        Messages.get(error.re ?? '') ??
+        Messages.get(error.regex ?? '') ??
         Messages.get(error.kind) ??
         Messages.get('default')!
       );

package/support/transformer/util.ts

@@ -171,11 +171,11 @@ class ${uniqueId} extends ${type.mappedClassName} {
         };
       }
     } else if (primaryExpr.key === 'template' && primaryExpr.template) {
-      const re = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
+      const regex = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
       attrs.match = {
-        re: new RegExp(re),
+        regex: new RegExp(regex),
         template: primaryExpr.template,
-        message: `{path} must match "${re}"`
+        message: `{path} must match "${regex}"`
       };
     }
 

package/src/service/changes.ts

@@ -1,152 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { Class } from '@travetto/runtime';
-import { ChangeEvent } from '@travetto/registry';
-
-import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
-
-interface FieldMapping {
-  path: SchemaFieldConfig[];
-  config: SchemaClassConfig;
-}
-
-export interface FieldChangeEvent {
-  cls: Class;
-  changes: ChangeEvent<SchemaFieldConfig>[];
-}
-
-interface SubSchemaChange {
-  path: SchemaFieldConfig[];
-  fields: ChangeEvent<SchemaFieldConfig>[];
-}
-
-export interface SchemaChange {
-  config: SchemaClassConfig;
-  subs: SubSchemaChange[];
-}
-
-export interface SchemaChangeEvent {
-  cls: Class;
-  change: SchemaChange;
-}
-
-/**
- * Schema change listener.  Handles all changes that occur via the SchemaRegistryIndex
- */
-class $SchemaChangeListener {
-
-  #emitter = new EventEmitter();
-  #mapping = new Map<string, Map<string, FieldMapping>>();
-
-  /**
-   * On schema change, emit the change event for the whole schema
-   * @param handler The function to call on schema change
-   */
-  onSchemaChange(handler: (event: SchemaChangeEvent) => void): void {
-    this.#emitter.on('schema', handler);
-  }
-
-  /**
-   * On schema field change, emit the change event for the whole schema
-   * @param handler The function to call on schema field change
-   */
-  onFieldChange(handler: (event: FieldChangeEvent) => void): void {
-    this.#emitter.on('field', handler);
-  }
-
-  /**
-   * Clear dependency mappings for a given class
-   */
-  clearSchemaDependency(cls: Class): void {
-    this.#mapping.delete(cls.Ⲑid);
-  }
-
-  /**
-   * Track a specific class for dependencies
-   * @param cls The target class
-   * @param parent The parent class
-   * @param path The path within the object hierarchy to arrive at the class
-   * @param config The configuration or the class
-   */
-  trackSchemaDependency(cls: Class, parent: Class, path: SchemaFieldConfig[], config: SchemaClassConfig): void {
-    const idValue = cls.Ⲑid;
-    if (!this.#mapping.has(idValue)) {
-      this.#mapping.set(idValue, new Map());
-    }
-    this.#mapping.get(idValue)!.set(parent.Ⲑid, { path, config });
-  }
-
-  /**
-   * Emit changes to the schema
-   * @param cls The class of the event
-   * @param changes The changes to send
-   */
-  emitSchemaChanges({ cls, changes }: FieldChangeEvent): void {
-    const updates = new Map<string, SchemaChange>();
-    const clsId = cls.Ⲑid;
-
-    if (this.#mapping.has(clsId)) {
-      const dependencies = this.#mapping.get(clsId)!;
-      for (const dependencyClsId of dependencies.keys()) {
-        if (!updates.has(dependencyClsId)) {
-          updates.set(dependencyClsId, { config: dependencies.get(dependencyClsId)!.config, subs: [] });
-        }
-        const childDependency = dependencies.get(dependencyClsId)!;
-        updates.get(dependencyClsId)!.subs.push({ path: [...childDependency.path], fields: changes });
-      }
-    }
-
-    for (const key of updates.keys()) {
-      this.#emitter.emit('schema', { cls: updates.get(key)!.config.class, change: updates.get(key)! });
-    }
-  }
-
-  /**
-   * Emit field level changes in the schema
-   * @param previous The previous class config
-   * @param current The current class config
-   */
-  emitFieldChanges(event: ChangeEvent<SchemaClassConfig>): void {
-    const previous = 'previous' in event ? event.previous : undefined;
-    const current = 'current' in event ? event.current : undefined;
-
-    const previousFields = new Set(Object.keys(previous?.fields ?? {}));
-    const currentFields = new Set(Object.keys(current?.fields ?? {}));
-
-    const changes: ChangeEvent<SchemaFieldConfig>[] = [];
-
-    for (const field of currentFields) {
-      if (!previousFields.has(field) && current) {
-        changes.push({ current: current.fields[field], type: 'added' });
-      }
-    }
-
-    for (const field of previousFields) {
-      if (!currentFields.has(field) && previous) {
-        changes.push({ previous: previous.fields[field], type: 'removing' });
-      }
-    }
-
-    // Handle class references changing, but keeping same id
-    const compareTypes = (a: Class, b: Class): boolean => a.Ⲑid ? a.Ⲑid === b.Ⲑid : a === b;
-
-    for (const field of currentFields) {
-      if (previousFields.has(field) && previous && current) {
-        const prevSchema = previous.fields[field];
-        const currSchema = current.fields[field];
-        if (
-          JSON.stringify(prevSchema) !== JSON.stringify(currSchema) ||
-          !compareTypes(prevSchema.type, currSchema.type)
-        ) {
-          changes.push({ previous: previous.fields[field], current: current.fields[field], type: 'changed' });
-        }
-      }
-    }
-
-    // Send field changes
-    this.#emitter.emit('field', { cls: current!.class, changes });
-    this.emitSchemaChanges({ cls: current!.class, changes });
-  }
-}
-
-export const SchemaChangeListener = new $SchemaChangeListener();

package/src/validate/regexp.ts

@@ -1,22 +0,0 @@
-import { TypedObject } from '@travetto/runtime';
-import { Messages } from './messages.ts';
-
-/**
- * List of common regular expressions for fields
- */
-export const CommonRegExp = {
-  email: /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
-  telephone: /^(\+?\d{1,3}(\s*-?\s*|\s+))?((\(\d{3}\))|\d{3})(\s*|-|[.])(\d{3})(\s*|-|[.])(\d{4})(\s+(x|ext[.]?)\s*\d+)?$/,
-  url: /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/,
-  simpleName: /^([a-zA-Z\u0080-\u024F]{0,100}(?:. |-| |')){0,10}[a-zA-Z\u0080-\u024F]+$/,
-  postalCode: /^\d{5}(?:[-\s]\d{4})?$/
-};
-
-export const CommonRegExpToName = new Map<RegExp, string>();
-
-// Rebind regexes
-for (const key of TypedObject.keys(CommonRegExp)) {
-  const name = `[[:${key}:]]`;
-  CommonRegExpToName.set(CommonRegExp[key], name);
-  Messages.set(name, Messages.get(key)!);
-}