@elliemae/ds-props-helpers 2.2.0-alpha.5 → 2.2.0-next.3

package/esm/validation/typescriptValidator.js

@@ -1,153 +1,202 @@
-import * as React from "react";
-import { describe } from "react-desc";
-import { useMemo, useState } from "react";
-import { throwRequiredError, throwTypeError } from "./errorTemplates";
-import {
-  isArray,
-  isFunction,
-  isJSXorNode,
-  isObject,
-  isPrimitiveType,
-  isSomethingWithParenthesis,
-  isString,
-  isUnion,
-  isUndefined,
-  isNull
-} from "./typescriptGuards";
-import { typescriptObjectParser } from "./typescriptParsers";
+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 { describe } from 'react-desc';
+import { useState, useMemo } from 'react';
+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 !== void 0 || value === "undefined") {
+  if (value !== undefined || value === 'undefined') {
     throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validateNull = (schemaName, key, value, format) => {
-  if (value !== null || value === "null") {
+  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) => {
-    validateValueWithFormat(schemaName, `${key}[${index}]`, val, format.slice(0, -2), validationsMemo, nextValidationsMemo);
+    // 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));
+  return !(typeof value !== 'object' || Array.isArray(value));
 }
+
 const validateObject = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  const valuesIsObject = isObjectType(value);
+  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);
-  keyValuePairs.forEach(([objectKey, objectValue]) => {
-    const trueKey = objectKey.slice(-1) === "?" ? objectKey.slice(0, -1) : objectKey;
+
+  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) {
-      validateValueWithFormat(schemaName, `${key}[${trueKey}]`, value[trueKey], objectValue, validationsMemo, nextValidationsMemo);
+      // 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) => {
+  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) => {
-  if (typeof value !== "function") {
+  // 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;
+  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) {
+
+  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, validationsMemo, nextValidationsMemo);
+    validateUndefined(schemaName, key, value, format);
   } else if (isNull(format)) {
-    validateNull(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
+    validateNull(schemaName, key, value, format);
   } else if (isPrimitiveType(format)) {
-    validatePrimitiveType(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
+    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, validationsMemo, nextValidationsMemo);
+    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, validationsMemo, nextValidationsMemo);
+    validateFunction(schemaName, key, value, format);
   } else if (isJSXorNode(format)) {
-    validateJSXorNode(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
+    validateJSXorNode(schemaName, key, value, format);
   } else if (isSomethingWithParenthesis(format)) {
     validateValueWithFormat(schemaName, key, value, format.slice(1, -1), validationsMemo, nextValidationsMemo);
   }
 };
-const validateTypescriptPropTypesImplementation = (props, schema, validationsMemo = {}, nextValidationsMemo = {}) => {
-  const { properties, name: schemaName } = schema;
-  properties.forEach((property) => {
-    const { name, format, required } = property;
+
+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] !== void 0 || required)) {
+
+    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({});
+  const [validationsMemo, setValidationsMemo] = useState({}); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
   const ComponentWithSchema = useMemo(() => {
-    const Component = () => {
-    };
+    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, ComponentWithSchema.toTypescript(), validationsMemo, nextValidationsMemo);
-    setValidationsMemo(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
-};
-//# sourceMappingURL=typescriptValidator.js.map
+
+export { useValidateTypescriptPropTypes, validateTypescriptPropTypesImplementation };

package/esm/validation/validator.js

@@ -1,26 +1,32 @@
-import * as React from "react";
-import { throwRequiredError, throwTypeError } from "./errorTemplates";
+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) => {
+  schema.properties.forEach(property => {
     const propertyName = property.name;
     const currentProp = props[propertyName];
-    const currentPropTypeOf = typeof currentProp;
-    const currentFormat = property.format;
-    let isValidReactElement = false;
+    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"))) {
+
+    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
-};
-//# sourceMappingURL=validator.js.map
+
+export { useValidatePropTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-props-helpers",
-  "version": "2.2.0-alpha.5",
+  "version": "2.2.0-next.3",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Props Helpers",
   "module": "./esm/index.js",
@@ -39,6 +39,22 @@
       "import": "./esm/tests/test.schema.js",
       "require": "./cjs/tests/test.schema.js"
     },
+    "./globalProps/useGetGlobalAttributes": {
+      "import": "./esm/globalProps/useGetGlobalAttributes.js",
+      "require": "./cjs/globalProps/useGetGlobalAttributes.js"
+    },
+    "./globalProps": {
+      "import": "./esm/globalProps/index.js",
+      "require": "./cjs/globalProps/index.js"
+    },
+    "./globalProps/globalAttributesPropTypes": {
+      "import": "./esm/globalProps/globalAttributesPropTypes.js",
+      "require": "./cjs/globalProps/globalAttributesPropTypes.js"
+    },
+    "./globalProps/constants": {
+      "import": "./esm/globalProps/constants.js",
+      "require": "./cjs/globalProps/constants.js"
+    },
     "./getProps": {
       "import": "./esm/getProps/index.js",
       "require": "./cjs/getProps/index.js"

package/types/globalProps/constants.d.ts

@@ -0,0 +1,3 @@
+import { AriaAttributes, DOMAttributes, HTMLAttributes } from 'react';
+export declare type GlobalAttributes<T = true> = Record<keyof (AriaAttributes & DOMAttributes<Element> & HTMLAttributes<Element>), T>;
+export declare const globalAttributes: GlobalAttributes<true>;