@elle96/ng-json-schema-manager 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elle96/ng-json-schema-manager",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Angular JSON Schema form renderer with Tailwind styling, external $ref support, and reactive forms.",
   "homepage": "https://luigiellebalotta.github.io/json-schema-manager/",
   "repository": {
@@ -26,10 +26,10 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@angular/common": "^20.0.0",
+    "@angular/common": "^22.0.0",
     "rxjs": "^7.8.0",
-    "@angular/core": "^20.0.0",
-    "@angular/forms": "^20.0.0"
+    "@angular/core": "^22.0.0",
+    "@angular/forms": "^22.0.0"
   },
   "dependencies": {
     "ajv": "^8.17.1",
@@ -39,14 +39,15 @@
   },
   "sideEffects": false,
   "module": "fesm2022/elle96-ng-json-schema-manager.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/elle96-ng-json-schema-manager.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/elle96-ng-json-schema-manager.d.ts",
       "default": "./fesm2022/elle96-ng-json-schema-manager.mjs"
     }
-  }
+  },
+  "type": "module"
 }

package/types/elle96-ng-json-schema-manager.d.ts

@@ -0,0 +1,460 @@
+import { AbstractControl, ControlValueAccessor, FormArray, FormControl, FormGroup } from "@angular/forms";
+import * as i0 from "@angular/core";
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from "@angular/core";
+import { ErrorObject } from "ajv";
+export type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export type JsonSchemaPrimitive = string | number | boolean | null;
+export interface JsonSchemaBase {
+  $schema?: string;
+  $id?: string;
+  $ref?: string;
+  $anchor?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $comment?: string;
+  title?: string;
+  description?: string;
+  type?: JsonSchemaType | JsonSchemaType[];
+  enum?: JsonSchemaPrimitive[];
+  const?: JsonSchemaPrimitive;
+  default?: unknown;
+  examples?: unknown[];
+  format?: string;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  nullable?: boolean;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  minContains?: number;
+  maxContains?: number;
+  required?: string[];
+}
+export interface JsonSchemaObject {
+  properties?: Record<string, JsonSchema>;
+  patternProperties?: Record<string, JsonSchema>;
+  additionalProperties?: boolean | JsonSchema;
+  unevaluatedProperties?: boolean | JsonSchema;
+  propertyNames?: JsonSchema;
+  dependencies?: Record<string, string[] | JsonSchema>;
+  dependentRequired?: Record<string, string[]>;
+  dependentSchemas?: Record<string, JsonSchema>;
+  minProperties?: number;
+  maxProperties?: number;
+}
+export interface JsonSchemaArray {
+  items?: JsonSchema | boolean;
+  prefixItems?: JsonSchema[];
+  additionalItems?: JsonSchema | boolean;
+  unevaluatedItems?: JsonSchema | boolean;
+  contains?: JsonSchema;
+}
+export interface JsonSchemaCombinators extends JsonSchemaBase {
+  allOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  not?: JsonSchema;
+  if?: JsonSchema;
+  then?: JsonSchema;
+  else?: JsonSchema;
+}
+export interface JsonSchema extends JsonSchemaBase, JsonSchemaObject, JsonSchemaArray, JsonSchemaCombinators {
+  $defs?: Record<string, JsonSchema>;
+  definitions?: Record<string, JsonSchema>;
+}
+export interface SchemaFieldContext {
+  schema: JsonSchema;
+  path: string;
+  required: boolean;
+}
+export interface SchemaError {
+  path: string;
+  message: string;
+  keyword: string;
+}
+export declare class JsonSchemaFormService {
+  buildControl(schema: JsonSchema, value?: unknown, required?: boolean): AbstractControl;
+  resolveType(schema: JsonSchema): JsonSchema['type'] | 'enum';
+  private applyCombinators;
+  resolveDynamicSchema(schema: JsonSchema, key: string): JsonSchema | undefined;
+  private resolveInitialValue;
+  private buildValidators;
+  private isRecord;
+  private mergeSchemas;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaFormService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class JsonSchemaResolverService {
+  resolve(schema: JsonSchema, baseUri?: string): Promise<JsonSchema>;
+  private resolveRefs;
+  private resolveExternalRef;
+  private fetchSchema;
+  private resolvePointer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaResolverService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type JsonSchemaDraft = 'draft4' | 'draft6' | 'draft7' | 'draft2019' | 'draft2020';
+export declare class JsonSchemaValidationService {
+  private readonly ajvCache;
+  validate(schema: JsonSchema, value: unknown): ErrorObject[];
+  /**
+   * Validates the schema itself against its JSON Schema meta-schema.
+   * Returns a list of SchemaError describing what is wrong in the schema definition.
+   */
+  validateSchema(schema: JsonSchema): SchemaError[];
+  detectDraft(schema: JsonSchema): JsonSchemaDraft;
+  private getAjv;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaValidationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class JsonSchemaStylesService {
+  private platformId;
+  private injected;
+  constructor(platformId: object);
+  inject(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaStylesService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Texts shown by the form. Every value can be overridden through the `labels` input of `jsm-json-schema-form`
+ * (e.g. to translate them); omitted keys keep the English default.
+ * `{n}` and `{name}` placeholders are replaced with the item number / field name.
+ */
+export interface JsonSchemaFormLabels {
+  /** Title used when the schema has none. */
+  formTitle: string;
+  resolving: string;
+  schemaErrorsTitle: string;
+  schemaErrorsHint: string;
+  addItem: string;
+  /** Hidden name of an array item, announced by screen readers ("Item {n}"). */
+  arrayItem: string;
+  remove: string;
+  add: string;
+  addProperty: string;
+  propertyName: string;
+  noItems: string;
+  mustContain: string;
+  min: string;
+  max: string;
+  /** "Option {n}" for oneOf/anyOf entries without a title. */
+  option: string;
+  /** "Section {n}" for allOf entries without a title. */
+  section: string;
+  example: string;
+  propertyNameRequired: string;
+  propertyNameInvalid: string;
+  propertyExists: string;
+  propertyNotAllowed: string;
+  errorRequired: string;
+  errorMinLength: string;
+  errorMaxLength: string;
+  errorMin: string;
+  errorMax: string;
+  errorEmail: string;
+  errorPattern: string;
+  errorInteger: string;
+  errorExclusiveMin: string;
+  errorExclusiveMax: string;
+  errorMultipleOf: string;
+  errorMinItems: string;
+  errorMaxItems: string;
+  errorUniqueItems: string;
+}
+export declare const DEFAULT_LABELS: JsonSchemaFormLabels;
+/** Replaces `{key}` placeholders in a label template. */
+export declare function formatLabel(template: string, values?: Record<string, string | number>): string;
+/** Character shown between the integer and decimal part of a number. */
+export type DecimalSeparator = '.' | ',';
+/**
+ * Options shared by every node of a form. Provided by `jsm-json-schema-form`, so each form instance has its own.
+ */
+export declare class JsonSchemaFormOptions {
+  decimalSeparator: DecimalSeparator;
+  labels: JsonSchemaFormLabels;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaFormOptions, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Keeps digits, a leading minus and a single decimal separator (written with `separator`);
+ * `,` and `.` are both accepted as input.
+ */
+export declare function sanitizeNumericText(text: string, separator: DecimalSeparator): string;
+/** Text → model: empty → `null`, a complete number → number, anything else stays a string (validation reports it). */
+export declare function parseNumericText(text: string): number | string | null;
+/** Model → text shown in the input. */
+export declare function formatNumeric(value: unknown, separator: DecimalSeparator): string;
+/** Shows decimals with the configured separator inside messages ("must be >= 0.1" → "must be >= 0,1"). */
+export declare function localizeNumbers(message: string, separator: DecimalSeparator): string;
+/**
+ * `ControlValueAccessor` for `number`/`integer` fields. The input is a text field (`inputmode="decimal"`), so the
+ * decimal comma is accepted, and the model always holds a JSON number once the text is a complete number.
+ * It never writes to the control while rendering or when the text is unchanged.
+ */
+export declare class NumericInputDirective implements ControlValueAccessor, OnChanges {
+  private readonly _el;
+  private readonly _renderer;
+  jsmDecimalSeparator: DecimalSeparator;
+  private _model;
+  private _onChange;
+  private _onTouched;
+  constructor(_el: ElementRef<HTMLInputElement>, _renderer: Renderer2);
+  private _show;
+  ngOnChanges(changes: SimpleChanges): void;
+  writeValue(value: unknown): void;
+  registerOnChange(fn: (value: unknown) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  onInput(): void;
+  onBlur(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NumericInputDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NumericInputDirective, "input[jsmNumeric]", never, {
+    "jsmDecimalSeparator": {
+      "alias": "jsmDecimalSeparator";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class JsonSchemaFormComponent implements OnChanges, OnDestroy {
+  private readonly schemaService;
+  private readonly resolver;
+  private readonly validation;
+  private readonly cdr;
+  protected readonly options: JsonSchemaFormOptions;
+  schema: JsonSchema;
+  value?: unknown;
+  data?: unknown;
+  allowAdditionalProperties: boolean;
+  /**
+   * Decimal separator of number/integer fields. `,` shows and accepts `0,5` (both `,` and `.` are accepted as input
+   * either way); the emitted value is always a JSON number.
+   */
+  decimalSeparator: DecimalSeparator;
+  /** Texts shown by the form (translate them here); omitted keys keep the English default. */
+  labels: Partial<JsonSchemaFormLabels>;
+  formReady: EventEmitter<FormGroup<any>>;
+  valueChange: EventEmitter<unknown>;
+  schemaReady: EventEmitter<JsonSchema>;
+  schemaErrors: EventEmitter<SchemaError[]>;
+  form: FormGroup;
+  rootControl: AbstractControl;
+  resolvedSchema?: JsonSchema;
+  errorsMap: Map<string, string[]>;
+  schemaErrorList: SchemaError[];
+  loading: boolean;
+  /** When true, all field errors are shown regardless of touched/dirty state. */
+  showErrors: boolean;
+  private valueSub?;
+  /** Last value emitted through valueChange (same reference the parent gets back through `data`/`value`). */
+  private lastEmitted;
+  constructor(schemaService: JsonSchemaFormService, resolver: JsonSchemaResolverService, validation: JsonSchemaValidationService, cdr: ChangeDetectorRef, options: JsonSchemaFormOptions, stylesService: JsonSchemaStylesService);
+  ngOnChanges(changes: SimpleChanges): void;
+  ngOnDestroy(): void;
+  /**
+   * Marks all fields as touched and forces error display across the entire form.
+   * Call this from an external "Save" or "Submit" button to show all validation errors at once.
+   * Returns true if the form is valid, false otherwise.
+   */
+  validate(): boolean;
+  private buildForm;
+  private updateErrors;
+  onRootReplaced(control: AbstractControl): void;
+  private attachValueSub;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaFormComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<JsonSchemaFormComponent, "jsm-json-schema-form", never, {
+    "schema": {
+      "alias": "schema";
+      "required": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+    };
+    "allowAdditionalProperties": {
+      "alias": "allowAdditionalProperties";
+      "required": false;
+    };
+    "decimalSeparator": {
+      "alias": "decimalSeparator";
+      "required": false;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+    };
+  }, {
+    "formReady": "formReady";
+    "valueChange": "valueChange";
+    "schemaReady": "schemaReady";
+    "schemaErrors": "schemaErrors";
+  }, never, never, true, never>;
+}
+export declare class JsonSchemaNodeComponent implements OnInit, OnDestroy {
+  private readonly schemaService;
+  private readonly validation;
+  private readonly cdr;
+  private readonly options;
+  schema: JsonSchema;
+  control: AbstractControl;
+  label: string;
+  required: boolean;
+  path: string;
+  errorsMap: Map<string, string[]>;
+  parent?: FormGroup | FormArray;
+  controlKey?: string | number;
+  allowAdditionalProperties: boolean;
+  /** When true, errors are shown regardless of touched/dirty state (e.g. triggered by an external save button). */
+  showErrors: boolean;
+  controlReplaced: EventEmitter<AbstractControl<any, any, any>>;
+  selectedOneOf: number;
+  selectedAnyOf: Set<number>;
+  newPropertyKey: string;
+  propertyError: string;
+  /** Tracks whether this primitive control has been touched (for OnPush CD). */
+  isTouched: boolean;
+  /** Unique DOM id base of this node: links labels, hints and errors to the control (WCAG 1.3.1, 4.1.2). */
+  readonly nodeId: string;
+  private valueSub?;
+  constructor(schemaService: JsonSchemaFormService, validation: JsonSchemaValidationService, cdr: ChangeDetectorRef, options: JsonSchemaFormOptions | null);
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  /** Called on blur of primitive inputs to trigger CD after Angular marks the control as touched. */
+  onBlur(): void;
+  isSimpleChild(key: string): boolean;
+  badgeClass(badge: string): string;
+  get nodeKind(): 'oneOf' | 'anyOf' | 'allOf' | 'object' | 'array' | 'primitive';
+  get resolvedType(): JsonSchema['type'] | 'enum';
+  get decimalSeparator(): DecimalSeparator;
+  /** Texts shown by the form (see `labels` of `jsm-json-schema-form`). */
+  get l(): JsonSchemaFormLabels;
+  fmt(template: string, values?: Record<string, string | number>): string;
+  localize(message: string): string;
+  optionLabel(index: number): string;
+  sectionLabel(index: number): string;
+  /** DOM id of a dynamic key label (keys may contain characters that are not valid in ids). */
+  keyId(key: string): string;
+  /** True when the error list of this primitive is shown (same gate as the error styling). */
+  get visibleError(): boolean;
+  /** Ids of the hint, example, media type and error texts that describe this control. */
+  get describedBy(): string | null;
+  selectOneOf(index: number): void;
+  /** WAI-ARIA tabs keyboard support: arrows, Home and End move between the oneOf options. */
+  onOneOfKeydown(event: KeyboardEvent): void;
+  /** `multipleOf` of this node's own schema, exposed as step metadata. */
+  get numericStep(): string;
+  get inputKind(): 'text' | 'number' | 'textarea' | 'select' | 'checkbox';
+  get inputType(): string;
+  get controlAsGroup(): FormGroup;
+  get controlAsFormControl(): FormControl;
+  get controlAsArray(): FormArray;
+  get arrayControls(): AbstractControl[];
+  get objectKeys(): string[];
+  get simpleKeys(): string[];
+  get complexKeys(): string[];
+  get canAddProperty(): boolean;
+  get errorsForPath(): string[];
+  /** Combined errors: Ajv errors from errorsMap + Angular validator errors on the control. */
+  get allErrors(): string[];
+  get metaBadges(): string[];
+  get activeVariant(): JsonSchema | null;
+  /**
+   * Sections rendered for an allOf: the schema's own keywords (without the allOf itself, which would render
+   * this node again forever) when it declares any, followed by every allOf entry.
+   */
+  get mergedAllOf(): JsonSchema[];
+  isRequired(key: string): boolean;
+  schemaForKey(key: string): JsonSchema;
+  isDynamicKey(key: string): boolean;
+  pathForChild(key: string | number): string;
+  addDynamicProperty(): void;
+  removeDynamicKey(key: string): void;
+  schemaForIndex(index: number): JsonSchema;
+  get canAddArrayItem(): boolean;
+  addArrayItem(): void;
+  removeArrayItem(index: number): void;
+  onOneOfChange(): void;
+  toggleAnyOf(index: number): void;
+  private replaceControl;
+  childControl(key: string): AbstractControl;
+  get effectiveSchema(): JsonSchema;
+  private applyConditional;
+  private applyDependencies;
+  private mergeSchemas;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaNodeComponent, [null, null, null, {
+    optional: true;
+  }]>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<JsonSchemaNodeComponent, "jsm-schema-node", never, {
+    "schema": {
+      "alias": "schema";
+      "required": true;
+    };
+    "control": {
+      "alias": "control";
+      "required": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+    };
+    "path": {
+      "alias": "path";
+      "required": false;
+    };
+    "errorsMap": {
+      "alias": "errorsMap";
+      "required": false;
+    };
+    "parent": {
+      "alias": "parent";
+      "required": false;
+    };
+    "controlKey": {
+      "alias": "controlKey";
+      "required": false;
+    };
+    "allowAdditionalProperties": {
+      "alias": "allowAdditionalProperties";
+      "required": false;
+    };
+    "showErrors": {
+      "alias": "showErrors";
+      "required": false;
+    };
+  }, {
+    "controlReplaced": "controlReplaced";
+  }, never, never, true, never>;
+}
+export declare class JsonSchemaFormModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaFormModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<JsonSchemaFormModule, never, [typeof JsonSchemaFormComponent, typeof JsonSchemaNodeComponent], [typeof JsonSchemaFormComponent, typeof JsonSchemaNodeComponent]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<JsonSchemaFormModule>;
+}
+/**
+ * Coerces values to the types declared by the schema so that the emitted value respects it:
+ * - `number`/`integer` numeric strings become JSON numbers (comma or dot as separator);
+ * - empty numeric values (`""`, whitespace, `null`) leave the key absent, never `""` or `0`;
+ * - integers with decimals are converted to their number but never truncated (validation reports them);
+ * - non-numeric strings are left unchanged (validation reports them).
+ * Descends into properties, patternProperties, additionalProperties, items, prefixItems and combinators.
+ * The same function feeds both the Ajv validation and the emitted value.
+ */
+export declare function normalizeValue(schema: JsonSchema, value: unknown): unknown;