@elliemae/ds-props-helpers 2.3.0-next.3 → 3.0.0-alpha.0

package/esm/validation/typescriptParsers.js

@@ -1,41 +0,0 @@
-import 'core-js/modules/esnext.async-iterator.for-each.js';
-import 'core-js/modules/esnext.iterator.constructor.js';
-import 'core-js/modules/esnext.iterator.for-each.js';
-
-/* eslint-disable complexity */
-const typescriptObjectParser = format => {
-  const keyValuePairs = []; // State of the algorithm
-
-  let lastKey = '';
-  let lastValue = '';
-  let shouldAppendToKey = true;
-
-  const pushPair = () => {
-    if (lastKey) keyValuePairs.push([lastKey, lastValue]);
-    lastKey = '';
-    lastValue = '';
-    shouldAppendToKey = true;
-  }; // Complex -- but working -- logic
-
-
-  let depth = 0;
-  format.split('').forEach(char => {
-    if (char === '{') {
-      depth += 1;
-      if (depth > 1) lastValue += char;
-    } else if (char === '}') {
-      if (depth > 1) lastValue += char;
-      depth -= 1;
-      if (depth === 1) pushPair();
-    } else if (char === ':') {
-      shouldAppendToKey = false;
-      if (depth > 1) lastValue += char;
-    } else if (char === ',') {
-      if (depth === 1) pushPair();else lastValue += char;
-    } else if (char === ' ') ; else if (shouldAppendToKey) lastKey += char;else lastValue += char;
-  });
-  pushPair();
-  return keyValuePairs;
-};
-
-export { typescriptObjectParser };

package/esm/validation/typescriptValidator.js

@@ -1,203 +0,0 @@
-import 'core-js/modules/esnext.async-iterator.for-each.js';
-import 'core-js/modules/esnext.iterator.constructor.js';
-import 'core-js/modules/esnext.iterator.for-each.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import { useState, useMemo } from 'react';
-import '../propTypes/PropTypes.js';
-import describe from '../propTypes/describe.js';
-import { throwRequiredError, throwTypeError } from './errorTemplates.js';
-import { isUndefined, isNull, isPrimitiveType, isUnion, isString, isArray, isObject, isFunction, isJSXorNode, isSomethingWithParenthesis } from './typescriptGuards.js';
-import { typescriptObjectParser } from './typescriptParsers.js';
-
-// =============================================================================
-// Atom Validators
-// =============================================================================
-// This functions will validate something from the data
-// and optionally recursively apply `validateValueWithFormat`
-// in smaller parts
-const validateUndefined = (schemaName, key, value, format) => {
-  if (value !== undefined || value === 'undefined') {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-const validateNull = (schemaName, key, value, format) => {
-  if (value !== null || value === 'null') {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-const validatePrimitiveType = (schemaName, key, value, format) => {
-  if (typeof value !== format) {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-const validateString = (schemaName, key, value, format) => {
-  if (value !== format.slice(1, -1)) {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-const validateArray = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  // Check that we have an array
-  if (!Array.isArray(value)) {
-    throwTypeError(schemaName, key, value, format);
-  } // Check that each element inside satisfies the format
-
-
-  value.forEach((val, index) => {
-    // this is a recursive func, we need to invoke it before it's defined.
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    validateValueWithFormat(schemaName, "".concat(key, "[").concat(index, "]"), val, format.slice(0, -2), validationsMemo, nextValidationsMemo);
-  });
-};
-
-function isObjectType(value) {
-  return !(typeof value !== 'object' || Array.isArray(value));
-}
-
-const validateObject = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  const valuesIsObject = isObjectType(value); // Check that we have an object
-
-  if (!valuesIsObject) {
-    throwTypeError(schemaName, key, value, format);
-    return;
-  }
-
-  if (format === 'object') return;
-  const keyValuePairs = typescriptObjectParser(format); // Now we have the key - value pairs
-  // Each key could either be required or not
-  // Just recursively check the object
-
-  keyValuePairs.forEach(_ref => {
-    let [objectKey, objectValue] = _ref;
-    const trueKey = objectKey.slice(-1) === '?' ? objectKey.slice(0, -1) : objectKey;
-
-    if (trueKey === objectKey && !(trueKey in value)) {
-      throwRequiredError(schemaName, key);
-    }
-
-    if (trueKey in value) {
-      // this is a recursive func, we need to invoke it before it's defined.
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      validateValueWithFormat(schemaName, "".concat(key, "[").concat(trueKey, "]"), value[trueKey], objectValue, validationsMemo, nextValidationsMemo);
-    }
-  });
-};
-
-const validateUnion = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  const possibilities = format.split(/\s?\|\s?/);
-  const errors = [];
-  possibilities.forEach(possibility => {
-    try {
-      // this is a recursive func, we need to invoke it before it's defined.
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      validateValueWithFormat(schemaName, key, value, possibility, validationsMemo, nextValidationsMemo);
-    } catch (e) {
-      errors.push(e);
-    }
-  });
-
-  if (errors.length === possibilities.length) {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-const validateFunction = (schemaName, key, value, format) => {
-  // Check that we have a function
-  if (typeof value !== 'function') {
-    throwTypeError(schemaName, key, value, format);
-  }
-};
-
-function isJSXElement(value) {
-  return value === null || typeof value === 'object' && value !== null && '$$typeof' in value;
-}
-
-const validateJSXorNode = (schemaName, key, value, format) => {
-  const valueIsJSX = isJSXElement(value);
-
-  if (format === 'JSX.Element' && !valueIsJSX) {
-    throwTypeError(schemaName, key, value, format);
-  }
-}; // =============================================================================
-// Schema validator
-// =============================================================================
-
-
-const validateValueWithFormat = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  nextValidationsMemo[value] = format;
-
-  if (value in validationsMemo) {
-    // We already validated this value on this format
-    return;
-  }
-
-  if (isUndefined(format)) {
-    validateUndefined(schemaName, key, value, format);
-  } else if (isNull(format)) {
-    validateNull(schemaName, key, value, format);
-  } else if (isPrimitiveType(format)) {
-    validatePrimitiveType(schemaName, key, value, format);
-  } else if (isUnion(format)) {
-    validateUnion(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if (isString(format)) {
-    validateString(schemaName, key, value, format);
-  } else if (isArray(format)) {
-    validateArray(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if (isObject(format)) {
-    validateObject(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if (isFunction(format)) {
-    validateFunction(schemaName, key, value, format);
-  } else if (isJSXorNode(format)) {
-    validateJSXorNode(schemaName, key, value, format);
-  } else if (isSomethingWithParenthesis(format)) {
-    validateValueWithFormat(schemaName, key, value, format.slice(1, -1), validationsMemo, nextValidationsMemo);
-  }
-};
-
-const validateTypescriptPropTypesImplementation = function (props, schema) {
-  let validationsMemo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  let nextValidationsMemo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  const {
-    properties,
-    name: schemaName
-  } = schema;
-  properties.forEach(property => {
-    const {
-      name,
-      format,
-      required
-    } = property;
-
-    if (required && !(name in props)) {
-      throwRequiredError(schema.name, name);
-    }
-
-    if (name in props && (props[name] !== undefined || required)) {
-      validateValueWithFormat(schemaName, name, props[name], format, validationsMemo, nextValidationsMemo);
-    }
-  });
-}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-const useValidateTypescriptPropTypes = (props, propTypes) => {
-  const [validationsMemo, setValidationsMemo] = useState({}); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-
-  const ComponentWithSchema = useMemo(() => {
-    const Component = () => {}; // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-
-
-    return describe(Component);
-  }, []); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,  @typescript-eslint/no-unsafe-assignment
-
-  ComponentWithSchema.propTypes = propTypes;
-  useMemo(() => {
-    const nextValidationsMemo = {};
-    validateTypescriptPropTypesImplementation(props, // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-    ComponentWithSchema.toTypescript(), validationsMemo, nextValidationsMemo);
-    setValidationsMemo(nextValidationsMemo); // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [props]);
-};
-
-export { useValidateTypescriptPropTypes, validateTypescriptPropTypesImplementation };

package/esm/validation/validator.js

@@ -1,32 +0,0 @@
-import 'core-js/modules/esnext.async-iterator.for-each.js';
-import 'core-js/modules/esnext.iterator.constructor.js';
-import 'core-js/modules/esnext.iterator.for-each.js';
-import { throwRequiredError, throwTypeError } from './errorTemplates.js';
-
-const useValidatePropTypes = (props, schema) => {
-  schema.properties.forEach(property => {
-    const propertyName = property.name;
-    const currentProp = props[propertyName];
-    const currentPropTypeOf = typeof currentProp; // eslint-disable-next-line max-len
-
-    const currentFormat = property.format; // this is csv representing types e.g.: "string"/"string,number"/"[object],string"
-
-    let isValidReactElement = false; // this depends on react desc definition
-
-    if (property.required && !Object.prototype.hasOwnProperty.call(props, property.name)) {
-      throwRequiredError(schema.name, property.name);
-    }
-
-    if (currentPropTypeOf !== 'undefined' && currentProp !== null) {
-      if (currentPropTypeOf === 'object' && Object.prototype.hasOwnProperty.call(currentProp, '$$typeof') && (currentFormat.includes('node') || currentFormat.includes('element'))) {
-        isValidReactElement = true;
-      }
-
-      if (!currentFormat.includes(currentPropTypeOf) && !currentFormat.includes(currentProp) && !isValidReactElement) {
-        throwTypeError(schema.name, propertyName, currentProp, currentFormat);
-      }
-    }
-  });
-};
-
-export { useValidatePropTypes };