@api-client/core 0.6.13 → 0.6.16

package/src/amf/ApiSchemaValues.ts

@@ -0,0 +1,411 @@
+import { DataMock, ILoremWordInit, ITypeHashInit, ITypeNumberInit, Time } from '@pawel-up/data-mock';
+import { AmfNamespace as ns } from "./definitions/Namespace.js";
+import { JsonDataNodeGenerator } from "./data-node/JsonDataNodeGenerator.js";
+import { parseBooleanInput, parseNumberInput, readTypedValue } from "./Utils.js";
+import { ApiParameter } from './definitions/Api.js';
+import { IAnyShape, IArrayNode, IArrayShape, IDataExample, IScalarNode, IScalarShape, IShapeUnion } from './definitions/Shapes.js';
+
+export interface IApiSchemaReadOptions {
+  /**
+   * Whether the value should be read only when the required property is set.
+   */
+  requiredOnly?: boolean;
+  /**
+   * Whether to read the examples to generate the value.
+   */
+  fromExamples?: boolean;
+}
+
+/**
+ * A utility class with helper functions to read values from a schema definition
+ */
+export class ApiSchemaValues {
+  static mocking = new DataMock();
+  
+  /**
+   * Reads the value to be set on an input. This is for Scalar shapes only.
+   *
+   * @returns The value to set on the input. Note, it is not cast to the type.
+   */
+  static readInputValue(parameter: ApiParameter, schema: IScalarShape, opts: IApiSchemaReadOptions = {}): any {
+    const { required } = parameter;
+    const { defaultValueStr, values } = schema;
+    if (!required && opts.requiredOnly === true) {
+      return undefined;
+    }
+    if (defaultValueStr) {
+      return ApiSchemaValues.readTypedValue(defaultValueStr, schema.dataType);
+    }
+    if (Array.isArray(values) && values.length) {
+      const firstEnum = values[0] as IScalarNode;
+      return ApiSchemaValues.readTypedValue(firstEnum.value, firstEnum.dataType);
+    }
+    if (opts.fromExamples) {
+      let examples: IDataExample[] | undefined;
+      if (Array.isArray(parameter.examples) && parameter.examples.length) {
+        // just in case when an ApiParameter was passed.
+        examples = parameter.examples.filter(i => typeof i !== 'string');
+      } else if (Array.isArray(schema.examples) && schema.examples.length) {
+        examples = schema.examples;
+      }
+      if (examples && examples.length) {
+        return ApiSchemaValues.inputValueFromExamples(examples);
+      }
+    }
+    return ApiSchemaValues.generateDefaultValue(schema);
+  }
+
+  /**
+   * @param parameter The parameter that has the array schema.
+   * @param schema The final schema to use to read the data from.
+   */
+  static readInputValues(parameter: ApiParameter, schema: IShapeUnion, opts: IApiSchemaReadOptions={}): any {
+    if (!parameter.required && opts.requiredOnly === true) {
+      // for a non required array items just skip showing example values
+      // as they are not crucial to make an HTTP request.
+      return [];
+    }
+    const { defaultValue } = schema;
+    if (defaultValue) {
+      const gen = new JsonDataNodeGenerator();
+      const result = gen.processNode(defaultValue);
+      if (Array.isArray(result)) {
+        return result;
+      }
+    }
+    const anySchema = schema as IAnyShape;
+    if (opts.fromExamples) {
+      let examples: IDataExample[] | undefined;
+      if (Array.isArray(parameter.examples) && parameter.examples.length) {
+        // just in case when an ApiParameter was passed.
+        examples = parameter.examples.filter(i => typeof i !== 'string');
+      } else if (Array.isArray(anySchema.examples) && anySchema.examples.length) {
+        examples = anySchema.examples;
+      }
+      return ApiSchemaValues.arrayValuesFromExamples(examples);
+    }
+    return [];
+  }
+
+  /**
+   * Reads the value for the form input(s) from examples.
+   */
+  static inputValueFromExamples(examples: IDataExample[]): any | null | undefined {
+    if (!Array.isArray(examples) || !examples.length) {
+      return undefined;
+    }
+    const [example] = examples;
+    const { structuredValue } = example;
+    if (!structuredValue) {
+      return undefined;
+    }
+    if (structuredValue.types.includes(ns.aml.vocabularies.data.Scalar)) {
+      const value = structuredValue as IScalarNode;
+      return ApiSchemaValues.readTypedValue(value.value, value.dataType);
+    }
+    return undefined;
+  }
+
+  /**
+   * Reads the array value from examples.
+   * @param examples Examples set on an array item.
+   */
+  static arrayValuesFromExamples(examples?: IDataExample[]): any[] {
+    const defaultReturn: any[] = [];
+    if (!Array.isArray(examples) || !examples.length) {
+      return defaultReturn;
+    }
+    const [example] = examples;
+    if (!example.structuredValue || !example.structuredValue.types.includes(ns.aml.vocabularies.data.Array)) {
+      return defaultReturn;
+    }
+    const value = example.structuredValue as IArrayNode;
+    const { members } = value;
+    if (!Array.isArray(members) || !members.length) {
+      return defaultReturn;
+    }
+    const result: any[] = [];
+    members.forEach((item) => {
+      const scalar = item as IScalarNode;
+      if (!scalar.value) {
+        return;
+      }
+      const typedValue = ApiSchemaValues.readTypedValue(scalar.value, scalar.dataType);
+      if (typeof value !== 'undefined' && value !== null) {
+        result.push(typedValue);
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Generates a default value from the schema type.
+   * For booleans it returns `false`, for numbers `0`, nulls `null`, etc.
+   * It does not generate a value for `string` types!
+   */
+  static generateDefaultValue(schema: IScalarShape): any {
+    const { dataType } = schema;
+    switch (dataType) {
+      case ns.w3.xmlSchema.string: return this.generateStringValue(schema);
+      // XML schema, for DataNode
+      case ns.w3.xmlSchema.number:
+      case ns.w3.xmlSchema.integer:
+      case ns.w3.xmlSchema.float:
+      case ns.w3.xmlSchema.long:
+      case ns.w3.xmlSchema.double:
+      case ns.aml.vocabularies.shapes.number:
+      case ns.aml.vocabularies.shapes.integer:
+      case ns.aml.vocabularies.shapes.float:
+      case ns.aml.vocabularies.shapes.long:
+      case ns.aml.vocabularies.shapes.double: return this.generateNumberValue(schema);
+      case ns.aml.vocabularies.shapes.boolean:
+      case ns.w3.xmlSchema.boolean: return this.mocking.types.boolean();
+      case ns.aml.vocabularies.shapes.nil:
+      case ns.w3.xmlSchema.nil: return null;
+      case ns.w3.xmlSchema.date: return new Time().dateOnly();
+      case ns.w3.xmlSchema.dateTime: return new Time().dateTime((schema.format === 'date-time' ? 'rfc3339' : schema.format) as "rfc3339" | "rfc2616");
+      case ns.aml.vocabularies.shapes.dateTimeOnly: return new Time().dateTimeOnly();
+      case ns.w3.xmlSchema.time: return new Time().timeOnly();
+      default: return undefined;
+    }
+  }
+
+  /**
+   * Generates a random number value given the schema definition for a number scalar.
+   */
+  static generateNumberValue(schema: IScalarShape): number {
+    const { minimum, maximum, format, multipleOf } = schema;
+    const init: ITypeNumberInit = {};
+    if (typeof minimum === 'number') {
+      init.min = minimum;
+    }
+    if (typeof maximum === 'number') {
+      init.max = maximum;
+    }
+    let generator: ((init?: number | ITypeNumberInit | undefined) => number) | undefined;
+    if (format && ['float', 'double'].includes(format)) {
+      generator = this.mocking.types.float.bind(this.mocking.types);
+    } else if (format && ['uint32', 'uint64', 'fixed32', 'fixed64'].includes(format)) {
+      // these are unsigned numbers, make sure the generate anything above 0
+      init.min = 0;
+      if (init.max && init.max < 0) {
+        delete init.max;
+      }
+    }
+
+    if (!generator) {
+      // by default generate an integer
+      generator = this.mocking.types.number.bind(this.mocking.types);
+    }
+    if (typeof multipleOf === 'number') {
+      init.precision = multipleOf;
+    }
+    return generator(init);
+  }
+
+  static generateStringValue(schema: IScalarShape): string {
+    const { minLength, maxLength, name='', format } = schema;
+    const lowerName = name.toLowerCase();
+    // we employ some heuristics to generate content based on the property name.
+    if (lowerName === 'description') {
+      return this.mocking.lorem.paragraph();
+    }
+    if (format === 'uuid') {
+      return this.mocking.types.uuid();
+    }
+    if (lowerName === 'id') {
+      const init: ITypeHashInit = { length: 12 };
+      const hasMin = typeof minLength === 'number';
+      if (hasMin) {
+        init.length = minLength;
+      } else if (!hasMin && typeof maxLength === 'number') {
+        init.length = maxLength;
+      }
+      return this.mocking.types.hash(init);
+    }
+    if (['name', 'fullname'].includes(lowerName)) {
+      return this.mocking.person.name();
+    }
+    if (lowerName === 'firstname') {
+      return this.mocking.person.firstName()
+    }
+    if (lowerName === 'lastname') {
+      return this.mocking.person.lastName()
+    }
+    // if (['zip', 'postcode', 'postalcode', 'zipcode'].includes(lowerName)) {
+    //   return this.mocking.word
+    // }
+
+    const init: ILoremWordInit = {};
+    const hasMin = typeof minLength === 'number';
+    if (hasMin) {
+      init.length = minLength;
+    } else if (!hasMin && typeof maxLength === 'number') {
+      init.length = maxLength;
+    }
+    
+    return this.mocking.lorem.word(init);
+  }
+
+  /**
+   * Casts the `value` to the corresponding data type
+   * @param type The w3 schema type
+   */
+  static readTypedValue(value: any, type?: string): any {
+    return readTypedValue(value, type);
+  }
+
+  /**
+   * @param schemaType Data type encoded in the parameter schema.
+   * @returns One of the HTML input element type values.
+   */
+  static readInputType(schemaType: string): 'number'|'boolean'|'date'|'time'|'datetime-local'|'text' {
+    switch (schemaType) {
+      case ns.aml.vocabularies.shapes.number:
+      case ns.aml.vocabularies.shapes.integer:
+      case ns.aml.vocabularies.shapes.float:
+      case ns.aml.vocabularies.shapes.long:
+      case ns.aml.vocabularies.shapes.double:
+      case ns.w3.xmlSchema.number:
+      case ns.w3.xmlSchema.integer:
+      case ns.w3.xmlSchema.float:
+      case ns.w3.xmlSchema.long:
+      case ns.w3.xmlSchema.double: return 'number';
+      case ns.w3.xmlSchema.date: return 'date';
+      case ns.w3.xmlSchema.time: return 'time';
+      case ns.w3.xmlSchema.dateTime:
+      case ns.aml.vocabularies.shapes.dateTimeOnly: return 'datetime-local';
+      case ns.aml.vocabularies.shapes.boolean:
+      case ns.w3.xmlSchema.boolean: return 'boolean';
+      default: return 'text';
+    }
+  }
+
+  /**
+   * Processes a value that should be a number.
+   */
+  static parseNumberInput(value: unknown, defaultValue?: number): number | undefined {
+    return parseNumberInput(value, defaultValue);
+  }
+
+  /**
+   * Processes a value that should be a number.
+   */
+  static parseBooleanInput(value: unknown, defaultValue?: boolean): boolean | undefined {
+    return parseBooleanInput(value, defaultValue);
+  }
+
+  /**
+   * Processes a value that should be a date formatted as yyyy-MM-dd.
+   */
+  static parseDateOnlyInput(value: any): string | undefined {
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) {
+      return undefined;
+    }
+    const result = d.toJSON();
+    const timeSeparator = result.indexOf('T');
+    return result.substring(0, timeSeparator);
+  }
+
+  /**
+   * Processes a value that should be a date formatted as hh:mm:ss.
+   */
+  static parseTimeOnlyInput(input: unknown): string|undefined {
+    const value = String(input).trim();
+    if (/^\d\d:\d\d$/.test(value)) {
+      return `${value}:00`;
+    }
+    if (/^\d\d:\d\d:\d\d$/.test(value)) {
+      return value;
+    }
+    return undefined;
+  }
+
+  /**
+   * Processes a value that should be a date formatted in one of the supported formats:
+   * - rfc3339 (default): 2016-02-28T16:41:41.090Z
+   * - rfc2616: Sun, 28 Feb 2016 16:41:41 GMT
+   */
+  static parseDateTimeInput(value: any, format: string = 'rfc3339'): string | undefined {
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) {
+      return undefined;
+    }
+    if (format === 'rfc2616') {
+      return d.toUTCString();
+    }
+    // OAS has the `date-time` format describing rfc3339.
+    if (['rfc3339', 'date-time'].includes(format)) {
+      return d.toISOString();
+    }
+    return undefined;
+  }
+
+  /**
+   * Processes a value that should be a date formatted as yyyy-MM-ddThh:mm
+   */
+  static parseDateTimeOnlyInput(value: any): string | undefined {
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) {
+      return undefined;
+    }
+    const jsonDate = d.toJSON(); // "yyyy-MM-ddThh:mm:ss.090Z"
+    const dot = jsonDate.indexOf('.');
+    return jsonDate.substring(0, dot);
+  }
+
+  /**
+   * Parses the the value according to array schema value.
+   */
+  static parseArrayInput(value: any, schema: IArrayShape): string|number|boolean|null|undefined {
+    const { items } = schema;
+    if (!items) {
+      return String(value);
+    }
+    return ApiSchemaValues.parseUserInput(value, items);
+  }
+
+  /**
+   * Parses the user entered value according to the schema definition.
+   */
+  static parseUserInput(value: any, schema: IShapeUnion): string|number|boolean|null|undefined {
+    if (!schema || value === undefined || value === null) {
+      return value;
+    }
+    const { types } = schema;
+    if (types.includes(ns.aml.vocabularies.shapes.ScalarShape)) {
+      return ApiSchemaValues.parseScalarInput(value, schema as IScalarShape);
+    }
+    if (types.includes(ns.aml.vocabularies.shapes.ArrayShape) || types.includes(ns.aml.vocabularies.shapes.MatrixShape)) {
+      return ApiSchemaValues.parseArrayInput(value, schema as IArrayShape);
+    }
+    return value;
+  }
+
+  /**
+   * Parses the user entered value as scalar value.
+   */
+  static parseScalarInput(value: unknown, schema: IScalarShape): string|number|boolean|null|undefined {
+    switch (schema.dataType) {
+      // AML shapes, for Shape
+      case ns.aml.vocabularies.shapes.number:
+      case ns.aml.vocabularies.shapes.integer:
+      case ns.aml.vocabularies.shapes.float:
+      case ns.aml.vocabularies.shapes.long:
+      case ns.aml.vocabularies.shapes.double:
+      case ns.w3.xmlSchema.number:
+      case ns.w3.xmlSchema.integer:
+      case ns.w3.xmlSchema.float:
+      case ns.w3.xmlSchema.long:
+      case ns.w3.xmlSchema.double: return ApiSchemaValues.parseNumberInput(value);
+      case ns.aml.vocabularies.shapes.boolean:
+      case ns.w3.xmlSchema.boolean: return ApiSchemaValues.parseBooleanInput(value);
+      case ns.w3.xmlSchema.date: return ApiSchemaValues.parseDateOnlyInput(value);
+      case ns.w3.xmlSchema.time: return ApiSchemaValues.parseTimeOnlyInput(value);
+      case ns.w3.xmlSchema.dateTime: return ApiSchemaValues.parseDateTimeInput(value, schema.format);
+      case ns.aml.vocabularies.shapes.dateTimeOnly: return ApiSchemaValues.parseDateTimeOnlyInput(value);
+      default: return String(value);
+    }
+  }
+}

package/src/amf/Utils.ts

@@ -0,0 +1,182 @@
+import { UrlEncoder } from "../lib/parsers/UrlEncoder.js";
+import { AmfNamespace } from "./definitions/Namespace.js";
+import { INodeShape, IPropertyShape, IShapeUnion, IUnionShape } from "./definitions/Shapes.js";
+
+/**
+   * @param indent The current indent
+   */
+export function toXml(obj: any, indent=0): string {
+  if (typeof obj !== 'object') {
+    return obj;
+  }
+  let xml = '';
+  const tabs = new Array(indent).fill('  ').join('');
+  Object.keys(obj).forEach((prop) => {
+    xml += Array.isArray(obj[prop]) ? '' : `${tabs}<${prop}>`;
+    if (Array.isArray(obj[prop])) {
+      (obj[prop] as any[]).forEach((item) => {
+        xml += `<${prop}>\n`;
+        xml += tabs;
+        xml += toXml({ ...item }, indent + 1);
+        xml += `</${prop}>\n`;
+      });
+    } else if (typeof obj[prop] === "object") {
+      xml += `\n`;
+      xml += toXml({ ...obj[prop] }, indent + 1);
+    } else {
+      xml += `${obj[prop]}`;
+    }
+    xml += Array.isArray(obj[prop]) ? '' : `</${prop}>\n`;
+  });
+  xml = xml.replace(/<\/?[0-9]{1,}>/g, '');
+  return xml
+}
+
+/**
+ * @param fill The fill value (spaces to put in front of the value)
+ * @param value The value to format
+ */
+export function formatXmlValue(fill: string, value: unknown): string {
+  const typed = String(value);
+  const parts = typed.split('\n').filter(i => !!i);
+  const formatted = parts.map(i => `${fill}${i}`).join('\n');
+  return formatted;
+}
+
+/**
+ * @param str A key or value to encode as x-www-form-urlencoded.
+ * @param replacePlus When set it replaces `%20` with `+`.
+ * @deprecated Use `UrlEncoder.encodeQueryString()` instead. 
+ */
+export function wwwFormUrlEncode(str: string, replacePlus?: boolean): string {
+  // Spec says to normalize newlines to \r\n and replace %20 spaces with +.
+  // jQuery does this as well, so this is likely to be widely compatible.
+  if (str === undefined) {
+    return '';
+  }
+  return UrlEncoder.encodeQueryString(String(str), replacePlus);
+}
+
+/**
+ * Processes a value that should be a number.
+ */
+export function parseNumberInput(value: any, defaultValue?: number): number | undefined {
+  if (typeof value === 'number') {
+    return value;
+  }
+  const n = Number(value);
+  if (Number.isNaN(n)) {
+    return defaultValue;
+  }
+  return n;
+}
+
+/**
+ * Processes a value that should be a number.
+ */
+export function parseBooleanInput(value: any, defaultValue?: boolean): boolean | undefined {
+  const type = typeof value;
+  if (type === 'boolean') {
+    return value;
+  }
+  if (type === 'string') {
+    const trimmed = value.trim();
+    if (trimmed === 'true') {
+      return true;
+    }
+    if (trimmed === 'false') {
+      return false;
+    }
+  }
+  return defaultValue;
+}
+
+/**
+ * Casts the `value` to the corresponding data type
+ * @param type The w3 schema type
+ */
+export function readTypedValue(value: any, type?: string): string | null | number | boolean | undefined {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  switch (type) {
+    case AmfNamespace.aml.vocabularies.shapes.number:
+    case AmfNamespace.aml.vocabularies.shapes.integer:
+    case AmfNamespace.aml.vocabularies.shapes.float:
+    case AmfNamespace.aml.vocabularies.shapes.long:
+    case AmfNamespace.aml.vocabularies.shapes.double:
+    case AmfNamespace.w3.xmlSchema.number:
+    case AmfNamespace.w3.xmlSchema.integer:
+    case AmfNamespace.w3.xmlSchema.float:
+    case AmfNamespace.w3.xmlSchema.long:
+    case AmfNamespace.w3.xmlSchema.double: return parseNumberInput(value, 0);
+    case AmfNamespace.aml.vocabularies.shapes.boolean:
+    case AmfNamespace.w3.xmlSchema.boolean: return parseBooleanInput(value, false);
+    case AmfNamespace.aml.vocabularies.shapes.nil:
+    case AmfNamespace.w3.xmlSchema.nil: 
+      return null;
+    default:
+      return value;
+  }
+}
+
+/**
+ * Picks the union member to render.
+ * @param anyOf The list of union members
+ * @param selectedUnions Optional list of domain ids of currently selected unions. When set is returns a member that is "selected" or the first member otherwise.
+ */
+export function getUnionMember(anyOf: IShapeUnion[], selectedUnions: string[] = []): IShapeUnion {
+  let renderedItem: IShapeUnion | undefined;
+  if (Array.isArray(selectedUnions) && selectedUnions.length) {
+    renderedItem = anyOf.find((item) => selectedUnions.includes(item.id));
+  }
+  if (!renderedItem) {
+    [renderedItem] = anyOf;
+  }
+  return renderedItem;
+}
+
+/**
+ * @param {ApiNodeShape} schema
+ * @param {string[]=} [selectedUnions=[]]
+ * @returns {ApiPropertyShape[]}
+ */
+export function collectNodeProperties(schema: INodeShape, selectedUnions?: string[]): IPropertyShape[] {
+  let result: IPropertyShape[] = [];
+  const { properties, inherits } = schema;
+  if (properties.length) {
+    result = [...properties];
+  }
+  if (Array.isArray(inherits) && inherits.length) {
+    inherits.forEach((s) => {
+      let node = s;
+      if (node.types.includes(AmfNamespace.aml.vocabularies.shapes.UnionShape)) {
+        const union = node as IUnionShape;
+        const { anyOf=[] } = union;
+        node = getUnionMember(anyOf, selectedUnions);
+      }
+      if (!node.types.includes(AmfNamespace.w3.shacl.NodeShape)) {
+        return;
+      }
+      const typed = node as INodeShape;
+      // const p = typed.properties;
+      // if (Array.isArray(p) && p.length) {
+      //   result = result.concat(p);
+      // }
+      const upper = collectNodeProperties(typed);
+      if (upper.length) {
+        result = result.concat(upper)
+      }
+    });
+  }
+  const merged: IPropertyShape[] = [];
+  result.forEach((item) => {
+    const existing = merged.find(i => i.name === item.name);
+    if (existing) {
+      // this should (?) merge properties from the two.
+      return;
+    }
+    merged.push(item);
+  });
+  return merged;
+}

package/src/amf/data-node/DataNodeBase.ts

@@ -0,0 +1,81 @@
+import { AmfNamespace as ns } from "../definitions/Namespace.js";
+import { IArrayNode, IDataNode, IObjectNode, IScalarNode } from "../definitions/Shapes.js";
+import { readTypedValue } from '../Utils.js';
+
+/**
+ * Base class for all schema generators based on AMF's DataNode which includes AMF's examples.
+ */
+export class DataNodeBase {
+  /**
+   * @param node The AMF data node to turn into a schema.
+   * @returns Undefined when passed non-DataNode domain element.
+   */
+  processNode(node: IDataNode): any | undefined {
+    const { types } = node;
+    if (types.includes(ns.aml.vocabularies.data.Scalar)) {
+      return this.processScalarNode(node as IScalarNode);
+    }
+    if (types.includes(ns.aml.vocabularies.data.Array)) {
+      return this.processArrayNode(node as IArrayNode);
+    }
+    if (types.includes(ns.aml.vocabularies.data.Object)) {
+      return this.processObjectNode(node as IObjectNode);
+    }
+    return undefined;
+  }
+
+  /**
+   * @param scalar The scalar node to process.
+   * @returns The scalar value.
+   */
+  processScalarNode(scalar: IScalarNode): any {
+    return readTypedValue(scalar.value, scalar.dataType);
+  }
+
+  /**
+   * @param array The array node to process.
+   * @returns Array value.
+   */
+  processArrayNode(array: IArrayNode): any[] {
+    const container: any[] = [];
+    array.members.forEach((member) => {
+      const result = this.processNode(member);
+      if (result !== undefined) {
+        container.push(result);
+      }
+    });
+    return container;
+  }
+
+  /**
+   * @param object The object node to process.
+   * @returns Object value.
+   */
+  processObjectNode(object: IObjectNode): any {
+    const container: any = {};
+    const { properties } = object;
+    Object.keys(properties).forEach((key) => {
+      const definition = properties[key];
+      const result = this.processNode(definition);
+      if (typeof result !== 'undefined') {
+        const name = this.normalizePropertyName(key);
+        container[name] = result;
+      }
+    });
+    return container;
+  }
+
+  /**
+   * Normalizes a property name. It decodes URL encoded values.
+   * @param name The property name to normalize
+   */
+  normalizePropertyName(name: string): string {
+    let result = name;
+    try {
+      result = decodeURIComponent(result)
+    } catch (e) {
+      // ...
+    }
+    return result;
+  }
+}

package/src/amf/data-node/JsonDataNodeGenerator.ts

@@ -0,0 +1,26 @@
+import { IDataNode } from '../definitions/Shapes.js';
+import { DataNodeBase } from './DataNodeBase.js';
+
+/** @typedef {import('../../helpers/api').ApiDataNode} ApiDataNode */
+
+/**
+ * A class that processes AMF's `structuredValue` into a JSON example.
+ */
+export class JsonDataNodeGenerator extends DataNodeBase {
+  /**
+   * Generates a JSON schema from the AMF's DataNode.
+   * 
+   * @param node The AMF's data node to transform into a schema.
+   * @returns Undefined when passed non-DataNode domain element.
+   */
+  generate(node: IDataNode): string | undefined {
+    const result = this.processNode(node);
+    if (!result) {
+      return result;
+    }
+    if (typeof result === 'string') {
+      return result;
+    }
+    return JSON.stringify(result, null, 2);
+  }
+}

package/src/amf/data-node/README.md

@@ -0,0 +1,3 @@
+# Data node based schema generators
+
+In this directory you will find libraries to generate a schema from AMF generated examples (DataNode).