@dnb/eufemia/extensions/forms/Tools/GenerateSchema.js

DNB Eufemia Design System UI Library

"use client";

import _pushInstanceProperty from "core-js-pure/stable/instance/push.js";
import { useCallback, useContext, useRef } from 'react';
import pointer, { isPath } from "../utils/json-pointer/index.js";
import DataContext from "../DataContext/Context.js";
export const schemaParams = ['minLength', 'maxLength', 'pattern', 'description', 'min', 'max', 'multipleOf', 'exclusiveMinimum', 'exclusiveMaximum'];
export default function GenerateSchema(props) {
  const {
    generateRef,
    filterData,
    log,
    children
  } = props || {};
  const {
    fieldInternalsRef,
    valueInternalsRef,
    getDataValue,
    data,
    hasContext
  } = useContext(DataContext);
  const dataRef = useRef({});
  dataRef.current = data;
  const generate = useCallback(() => {
    var _getDataValue;
    const schema = Object.entries(fieldInternalsRef?.current || {}).reduce((acc, [path, {
      props
    }]) => {
      if (isPath(path)) {
        const objectKey = path.substring(1);
        const pathList = objectKey.split('/');
        const slashCount = pathList.length;
        const type = props.valueType || 'string';
        const propertyValue = {
          type
        };
        for (const prop of schemaParams) {
          if (props[prop]) {
            propertyValue[prop] = props[prop];
          }
        }
        if (slashCount > 1) {
          const nestedPath = [''];
          for (const path of pathList) {
            _pushInstanceProperty(nestedPath).call(nestedPath, path);
            const pathToSet = nestedPath.join('/properties/');
            const isLast = nestedPath.length - 1 === pathList.length;
            const existingValue = pointer.has(acc, pathToSet) ? pointer.get(acc, pathToSet) : null;
            const pathValue = isLast ? propertyValue : existingValue;
            if (isLast) {
              if (filterData?.[pathToSet] !== false) {
                pointer.set(acc, pathToSet, pathValue);
              }
            } else {
              const pathValue = {
                type: 'object',
                ...existingValue
              };
              const required = [];
              if (props.required) {
                _pushInstanceProperty(required).call(required, pathList.at(-1));
              }
              if (existingValue?.required) {
                _pushInstanceProperty(required).call(required, ...existingValue.required);
              }
              if (required.length > 0) {
                pathValue.required = required;
              }
              if (filterData?.[pathToSet] !== false) {
                pointer.set(acc, pathToSet, pathValue);
              }
            }
          }
        } else {
          if (filterData?.[path] !== false) {
            pointer.set(acc.properties, path, propertyValue);
          }
          if (props.required) {
            var _context;
            _pushInstanceProperty(_context = acc.required).call(_context, objectKey);
          }
        }
      }
      return acc;
    }, {
      type: 'object',
      properties: {},
      required: []
    });
    const propsOfFields = Object.entries(fieldInternalsRef?.current || {}).reduce((acc, [path, {
      props
    }]) => {
      if (isPath(path)) {
        const propertyValue = {};
        for (const prop in props) {
          if (props[prop] !== undefined && typeof props[prop] !== 'function') {
            propertyValue[prop] = props[prop];
          }
        }
        pointer.set(acc, path, propertyValue);
      }
      return acc;
    }, {});
    const propsOfValues = Object.entries(valueInternalsRef?.current || {}).reduce((acc, [path, {
      props
    }]) => {
      if (isPath(path)) {
        const propertyValue = {};
        for (const prop in props) {
          if (props[prop] !== undefined && typeof props[prop] !== 'function') {
            propertyValue[prop] = props[prop];
          }
        }
        pointer.set(acc, path, propertyValue);
      }
      return acc;
    }, {});
    if (schema.required.length === 0) {
      delete schema.required;
    }
    return {
      schema,
      data: (_getDataValue = getDataValue?.('/')) !== null && _getDataValue !== void 0 ? _getDataValue : dataRef.current,
      propsOfFields,
      propsOfValues
    };
  }, [fieldInternalsRef, filterData, getDataValue, valueInternalsRef]);
  if (hasContext) {
    if (log) {
      console.log(generate().schema);
    }
    if (generateRef) {
      const mutableGenerateRef = generateRef;
      mutableGenerateRef.current = generate;
    }
  }
  return children;
}
//# sourceMappingURL=GenerateSchema.js.map