@elliemae/ds-props-helpers 2.3.0-alpha.2 → 2.3.0-alpha.3

package/esm/propTypes/describe.js

@@ -0,0 +1,52 @@
+import * as React from "react";
+import { convertPropType } from "./describeConversions";
+import descToTypescript from "./toTypescript";
+function describe(ComponentInstance) {
+  if (!ComponentInstance) {
+    throw new Error("react-desc: component is required");
+  }
+  const documentation = {
+    propTypes: {}
+  };
+  const DocumentedComponent = ComponentInstance;
+  const addDocumentationProp = (propName) => {
+    const func = (value) => {
+      documentation[propName] = value;
+      return DocumentedComponent;
+    };
+    return func;
+  };
+  DocumentedComponent.availableAt = addDocumentationProp("availableAt");
+  DocumentedComponent.description = addDocumentationProp("description");
+  DocumentedComponent.details = addDocumentationProp("details");
+  DocumentedComponent.deprecated = addDocumentationProp("deprecated");
+  DocumentedComponent.usage = addDocumentationProp("usage");
+  DocumentedComponent.intrinsicElement = addDocumentationProp("intrinsicElement");
+  DocumentedComponent.toTypescript = () => descToTypescript(ComponentInstance, documentation);
+  Object.defineProperty(DocumentedComponent, "propTypes", {
+    get: () => DocumentedComponent.propTypesValue,
+    set: (value) => {
+      if (!DocumentedComponent.propTypesValue) {
+        DocumentedComponent.propTypesValue = {};
+      }
+      Object.keys(value).forEach((name) => {
+        const propType = value[name];
+        let realPropType;
+        documentation.propTypes[name] = propType;
+        realPropType = convertPropType(propType);
+        if (value[name].reactDesc.required) {
+          realPropType = realPropType.isRequired;
+        }
+        DocumentedComponent.propTypesValue[name] = realPropType;
+        return propType;
+      });
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return DocumentedComponent;
+}
+export {
+  describe as default
+};
+//# sourceMappingURL=describe.js.map

package/esm/propTypes/describe.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/propTypes/describe.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable react/forbid-foreign-prop-types */\nimport { Requireable, Validator } from 'prop-types';\nimport React from 'react';\nimport { convertPropType } from './describeConversions';\nimport descToTypescript from './toTypescript';\nimport { ReactDescT, ComponentDocumentation, DocumentedReactComponent } from './types';\n\nexport default function describe<C>(ComponentInstance: React.ComponentType<C>) {\n  if (!ComponentInstance) {\n    throw new Error('react-desc: component is required');\n  }\n\n  const documentation: ComponentDocumentation = {\n    propTypes: {},\n  };\n\n  const DocumentedComponent = ComponentInstance as DocumentedReactComponent<C>;\n\n  const addDocumentationProp = <T extends keyof ComponentDocumentation>(propName: T) => {\n    const func = (value: ComponentDocumentation[T]): DocumentedReactComponent<C> => {\n      documentation[propName] = value;\n      return DocumentedComponent;\n    };\n    return func;\n  };\n\n  DocumentedComponent.availableAt = addDocumentationProp('availableAt');\n  DocumentedComponent.description = addDocumentationProp('description');\n  DocumentedComponent.details = addDocumentationProp('details');\n  DocumentedComponent.deprecated = addDocumentationProp('deprecated');\n  DocumentedComponent.usage = addDocumentationProp('usage');\n  DocumentedComponent.intrinsicElement = addDocumentationProp('intrinsicElement');\n\n  DocumentedComponent.toTypescript = () => descToTypescript(ComponentInstance, documentation);\n\n  Object.defineProperty(DocumentedComponent, 'propTypes', {\n    get: () => DocumentedComponent.propTypesValue,\n    set: (value: Record<string, ReactDescT>) => {\n      if (!DocumentedComponent.propTypesValue) {\n        DocumentedComponent.propTypesValue = {};\n      }\n\n      Object.keys(value).forEach((name) => {\n        const propType: ReactDescT = value[name];\n        let realPropType: Requireable<unknown> | Validator<unknown>;\n        documentation.propTypes[name] = propType;\n        realPropType = convertPropType(propType);\n        if (value[name].reactDesc.required) {\n          realPropType = (realPropType as Requireable<unknown>).isRequired;\n        }\n        DocumentedComponent.propTypesValue[name] = realPropType as Validator<unknown>;\n        return propType;\n      });\n    },\n    enumerable: true,\n    configurable: true,\n  });\n\n  return DocumentedComponent;\n}\n"],
+  "mappings": "AAAA;ACGA;AACA;AAGe,kBAAqB,mBAA2C;AAC7E,MAAI,CAAC,mBAAmB;AACtB,UAAM,IAAI,MAAM;AAAA;AAGlB,QAAM,gBAAwC;AAAA,IAC5C,WAAW;AAAA;AAGb,QAAM,sBAAsB;AAE5B,QAAM,uBAAuB,CAAyC,aAAgB;AACpF,UAAM,OAAO,CAAC,UAAkE;AAC9E,oBAAc,YAAY;AAC1B,aAAO;AAAA;AAET,WAAO;AAAA;AAGT,sBAAoB,cAAc,qBAAqB;AACvD,sBAAoB,cAAc,qBAAqB;AACvD,sBAAoB,UAAU,qBAAqB;AACnD,sBAAoB,aAAa,qBAAqB;AACtD,sBAAoB,QAAQ,qBAAqB;AACjD,sBAAoB,mBAAmB,qBAAqB;AAE5D,sBAAoB,eAAe,MAAM,iBAAiB,mBAAmB;AAE7E,SAAO,eAAe,qBAAqB,aAAa;AAAA,IACtD,KAAK,MAAM,oBAAoB;AAAA,IAC/B,KAAK,CAAC,UAAsC;AAC1C,UAAI,CAAC,oBAAoB,gBAAgB;AACvC,4BAAoB,iBAAiB;AAAA;AAGvC,aAAO,KAAK,OAAO,QAAQ,CAAC,SAAS;AACnC,cAAM,WAAuB,MAAM;AACnC,YAAI;AACJ,sBAAc,UAAU,QAAQ;AAChC,uBAAe,gBAAgB;AAC/B,YAAI,MAAM,MAAM,UAAU,UAAU;AAClC,yBAAgB,aAAsC;AAAA;AAExD,4BAAoB,eAAe,QAAQ;AAC3C,eAAO;AAAA;AAAA;AAAA,IAGX,YAAY;AAAA,IACZ,cAAc;AAAA;AAGhB,SAAO;AAAA;",
+  "names": []
+}

package/esm/propTypes/describeConversions.js

@@ -0,0 +1,76 @@
+import * as React from "react";
+import PropTypes from "prop-types";
+import { tupleValidator } from "./customPropTypes";
+import {
+  hasArguments,
+  isArrayOf,
+  isExact,
+  isInstanceOf,
+  isObjectOf,
+  isOneOf,
+  isOneOfType,
+  isShape
+} from "./describeGuards";
+const enrichPropType = (propType, reactDesc) => {
+  const func = (props, propName, componentName, ...rest) => {
+    if (reactDesc && reactDesc.deprecated && propName in props && !reactDesc.warned) {
+      const { version = "", message = "" } = reactDesc.deprecated;
+      const warning = `"${propName}" property of "${componentName}" will be deprecated on VERSION: ${version}.
+${message}`;
+      console.warn(warning);
+      reactDesc.warned = true;
+    }
+    return propType(props, propName, componentName, ...rest);
+  };
+  Object.defineProperty(func, "isRequired", Object.getOwnPropertyDescriptor(propType, "isRequired"));
+  return func;
+};
+const convertArray = (array) => array.map((type) => convertPropType(type));
+const convertShape = (_shape) => {
+  const result = {};
+  Object.keys(_shape).forEach((key) => {
+    result[key] = convertPropType(_shape[key]);
+  });
+  return result;
+};
+const convertPropType = (propType) => {
+  if (!propType || !propType.type) {
+    throw new Error(`react-desc: unknown error -- proptype is not well defined`);
+  }
+  if (propType.type === "tuple") {
+    return enrichPropType(PropTypes.arrayOf(tupleValidator(convertArray(propType.args))), propType.reactDesc);
+  }
+  const realPropType = PropTypes[propType.type];
+  if (!realPropType) {
+    throw new Error(`react-desc: unknown type ${propType.type}`);
+  }
+  if (hasArguments(propType, realPropType)) {
+    if (isOneOfType(propType, realPropType)) {
+      return enrichPropType(realPropType(convertArray(propType.args)), propType.reactDesc);
+    }
+    if (isArrayOf(propType, realPropType)) {
+      return enrichPropType(realPropType(convertPropType(propType.args)), propType.reactDesc);
+    }
+    if (isShape(propType, realPropType)) {
+      return enrichPropType(realPropType(convertShape(propType.args)), propType.reactDesc);
+    }
+    if (isInstanceOf(propType, realPropType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+    if (isOneOf(propType, realPropType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+    if (isObjectOf(propType, realPropType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+    if (isExact(propType, realPropType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+    throw new Error(`react-desc: unknown error -- proptype with args is not matching`);
+  }
+  return enrichPropType(realPropType, propType.reactDesc);
+};
+export {
+  convertPropType
+};
+//# sourceMappingURL=describeConversions.js.map

package/esm/propTypes/describeConversions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/propTypes/describeConversions.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable max-statements */\n/* eslint-disable complexity */\n/* eslint-disable max-params */\n/* eslint-disable no-console */\n/* eslint-disable @typescript-eslint/no-use-before-define */\nimport PropTypes, { ValidationMap, Requireable } from 'prop-types';\nimport { tupleValidator } from './customPropTypes';\nimport {\n  hasArguments,\n  isArrayOf,\n  isExact,\n  isInstanceOf,\n  isObjectOf,\n  isOneOf,\n  isOneOfType,\n  isShape,\n} from './describeGuards';\nimport { ReactDescT, ReactDescObjT, InstanceOfT, OneOfT, ObjectOfT, ExactT } from './types';\n\nconst enrichPropType = (propType: Requireable<unknown>, reactDesc: ReactDescObjT): Requireable<unknown> => {\n  const func = (props: Record<string, unknown>, propName: string, componentName: string, ...rest: [string, string]) => {\n    if (reactDesc && reactDesc.deprecated && propName in props && !reactDesc.warned) {\n      const { version = '', message = '' } = reactDesc.deprecated;\n      const warning = `\"${propName}\" property of \"${componentName}\" will be deprecated on VERSION: ${version}.\\n${message}`;\n      console.warn(warning);\n      reactDesc.warned = true;\n    }\n    return propType(props, propName, componentName, ...rest);\n  };\n  Object.defineProperty(\n    func,\n    'isRequired',\n    Object.getOwnPropertyDescriptor(propType, 'isRequired') as PropertyDescriptor,\n  );\n  return func as Requireable<unknown>;\n};\n\nconst convertArray = (array: ReactDescT[]): Requireable<unknown>[] => array.map((type) => convertPropType(type));\n\nconst convertShape = (_shape: Record<string, ReactDescT>): ValidationMap<Record<string, unknown>> => {\n  const result: ValidationMap<Record<string, unknown>> = {};\n  Object.keys(_shape).forEach((key) => {\n    result[key] = convertPropType(_shape[key]);\n  });\n  return result;\n};\n\nexport const convertPropType = (propType: ReactDescT): Requireable<unknown> => {\n  if (!propType || !propType.type) {\n    throw new Error(`react-desc: unknown error -- proptype is not well defined`);\n  }\n\n  // DimSum PropTypes conversion\n  if (propType.type === 'tuple') {\n    return enrichPropType(\n      PropTypes.arrayOf(tupleValidator(convertArray(propType.args as ReactDescT[]))),\n      propType.reactDesc,\n    );\n  }\n\n  // Default PropType conversion\n  const realPropType = PropTypes[propType.type];\n\n  if (!realPropType) {\n    throw new Error(`react-desc: unknown type ${propType.type}`);\n  }\n\n  if (hasArguments(propType, realPropType)) {\n    if (isOneOfType(propType, realPropType)) {\n      return enrichPropType(realPropType(convertArray(propType.args as ReactDescT[])), propType.reactDesc);\n    }\n    if (isArrayOf(propType, realPropType)) {\n      return enrichPropType(realPropType(convertPropType(propType.args as ReactDescT)), propType.reactDesc);\n    }\n    if (isShape(propType, realPropType)) {\n      return enrichPropType(\n        realPropType(convertShape(propType.args as Record<string, ReactDescT>)),\n        propType.reactDesc,\n      );\n    }\n    if (isInstanceOf(propType, realPropType)) {\n      return enrichPropType(realPropType(propType.args as Parameters<InstanceOfT>[0]), propType.reactDesc);\n    }\n    if (isOneOf(propType, realPropType)) {\n      return enrichPropType(realPropType(propType.args as Parameters<OneOfT>[0]), propType.reactDesc);\n    }\n    if (isObjectOf(propType, realPropType)) {\n      return enrichPropType(realPropType(propType.args as Parameters<ObjectOfT>[0]), propType.reactDesc);\n    }\n    if (isExact(propType, realPropType)) {\n      return enrichPropType(realPropType(propType.args as Parameters<ExactT>[0]), propType.reactDesc);\n    }\n    throw new Error(`react-desc: unknown error -- proptype with args is not matching`);\n  }\n\n  return enrichPropType(realPropType, propType.reactDesc);\n};\n"],
+  "mappings": "AAAA;ACKA;AACA;AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,MAAM,iBAAiB,CAAC,UAAgC,cAAmD;AACzG,QAAM,OAAO,CAAC,OAAgC,UAAkB,kBAA0B,SAA2B;AACnH,QAAI,aAAa,UAAU,cAAc,YAAY,SAAS,CAAC,UAAU,QAAQ;AAC/E,YAAM,EAAE,UAAU,IAAI,UAAU,OAAO,UAAU;AACjD,YAAM,UAAU,IAAI,0BAA0B,iDAAiD;AAAA,EAAa;AAC5G,cAAQ,KAAK;AACb,gBAAU,SAAS;AAAA;AAErB,WAAO,SAAS,OAAO,UAAU,eAAe,GAAG;AAAA;AAErD,SAAO,eACL,MACA,cACA,OAAO,yBAAyB,UAAU;AAE5C,SAAO;AAAA;AAGT,MAAM,eAAe,CAAC,UAAgD,MAAM,IAAI,CAAC,SAAS,gBAAgB;AAE1G,MAAM,eAAe,CAAC,WAA+E;AACnG,QAAM,SAAiD;AACvD,SAAO,KAAK,QAAQ,QAAQ,CAAC,QAAQ;AACnC,WAAO,OAAO,gBAAgB,OAAO;AAAA;AAEvC,SAAO;AAAA;AAGF,MAAM,kBAAkB,CAAC,aAA+C;AAC7E,MAAI,CAAC,YAAY,CAAC,SAAS,MAAM;AAC/B,UAAM,IAAI,MAAM;AAAA;AAIlB,MAAI,SAAS,SAAS,SAAS;AAC7B,WAAO,eACL,UAAU,QAAQ,eAAe,aAAa,SAAS,SACvD,SAAS;AAAA;AAKb,QAAM,eAAe,UAAU,SAAS;AAExC,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI,MAAM,4BAA4B,SAAS;AAAA;AAGvD,MAAI,aAAa,UAAU,eAAe;AACxC,QAAI,YAAY,UAAU,eAAe;AACvC,aAAO,eAAe,aAAa,aAAa,SAAS,QAAwB,SAAS;AAAA;AAE5F,QAAI,UAAU,UAAU,eAAe;AACrC,aAAO,eAAe,aAAa,gBAAgB,SAAS,QAAsB,SAAS;AAAA;AAE7F,QAAI,QAAQ,UAAU,eAAe;AACnC,aAAO,eACL,aAAa,aAAa,SAAS,QACnC,SAAS;AAAA;AAGb,QAAI,aAAa,UAAU,eAAe;AACxC,aAAO,eAAe,aAAa,SAAS,OAAqC,SAAS;AAAA;AAE5F,QAAI,QAAQ,UAAU,eAAe;AACnC,aAAO,eAAe,aAAa,SAAS,OAAgC,SAAS;AAAA;AAEvF,QAAI,WAAW,UAAU,eAAe;AACtC,aAAO,eAAe,aAAa,SAAS,OAAmC,SAAS;AAAA;AAE1F,QAAI,QAAQ,UAAU,eAAe;AACnC,aAAO,eAAe,aAAa,SAAS,OAAgC,SAAS;AAAA;AAEvF,UAAM,IAAI,MAAM;AAAA;AAGlB,SAAO,eAAe,cAAc,SAAS;AAAA;",
+  "names": []
+}

package/esm/propTypes/describeGuards.js

@@ -0,0 +1,20 @@
+import * as React from "react";
+const hasArguments = (propType, realPropType) => !!propType.args;
+const isOneOfType = (propType, realPropType) => propType.type === "oneOfType";
+const isArrayOf = (propType, realPropType) => propType.type === "arrayOf";
+const isShape = (propType, realPropType) => propType.type === "shape";
+const isInstanceOf = (propType, realPropType) => propType.type === "instanceOf";
+const isOneOf = (propType, realPropType) => propType.type === "oneOf";
+const isObjectOf = (propType, realPropType) => propType.type === "objectOf";
+const isExact = (propType, realPropType) => propType.type === "exact";
+export {
+  hasArguments,
+  isArrayOf,
+  isExact,
+  isInstanceOf,
+  isObjectOf,
+  isOneOf,
+  isOneOfType,
+  isShape
+};
+//# sourceMappingURL=describeGuards.js.map

package/esm/propTypes/describeGuards.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/propTypes/describeGuards.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import {\n  AllPropTypes,\n  ArrayOfT,\n  ExactT,\n  InstanceOfT,\n  ObjectOfT,\n  OneOfT,\n  OneOfTypeT,\n  ParametizedPropTypes,\n  ReactDescT,\n  ShapeT,\n} from './types';\n\nexport const hasArguments = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is ParametizedPropTypes =>\n  !!propType.args;\n\nexport const isOneOfType = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is OneOfTypeT =>\n  propType.type === 'oneOfType';\n\nexport const isArrayOf = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is ArrayOfT =>\n  propType.type === 'arrayOf';\n\nexport const isShape = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is ShapeT =>\n  propType.type === 'shape';\n\nexport const isInstanceOf = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is InstanceOfT =>\n  propType.type === 'instanceOf';\n\nexport const isOneOf = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is OneOfT =>\n  propType.type === 'oneOf';\n\nexport const isObjectOf = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is ObjectOfT =>\n  propType.type === 'objectOf';\n\nexport const isExact = (propType: ReactDescT, realPropType: AllPropTypes): realPropType is ExactT =>\n  propType.type === 'exact';\n"],
+  "mappings": "AAAA;ACaO,MAAM,eAAe,CAAC,UAAsB,iBACjD,CAAC,CAAC,SAAS;AAEN,MAAM,cAAc,CAAC,UAAsB,iBAChD,SAAS,SAAS;AAEb,MAAM,YAAY,CAAC,UAAsB,iBAC9C,SAAS,SAAS;AAEb,MAAM,UAAU,CAAC,UAAsB,iBAC5C,SAAS,SAAS;AAEb,MAAM,eAAe,CAAC,UAAsB,iBACjD,SAAS,SAAS;AAEb,MAAM,UAAU,CAAC,UAAsB,iBAC5C,SAAS,SAAS;AAEb,MAAM,aAAa,CAAC,UAAsB,iBAC/C,SAAS,SAAS;AAEb,MAAM,UAAU,CAAC,UAAsB,iBAC5C,SAAS,SAAS;",
+  "names": []
+}

package/esm/propTypes/index.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+import PropTypes from "./PropTypes";
+import describe from "./describe";
+export {
+  PropTypes,
+  describe
+};
+//# sourceMappingURL=index.js.map

package/esm/propTypes/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/propTypes/index.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import PropTypes from './PropTypes';\nimport describe from './describe';\n\nexport { describe, PropTypes };\n"],
+  "mappings": "AAAA;ACAA;AACA;",
+  "names": []
+}

package/esm/propTypes/toTypescript.js

@@ -0,0 +1,110 @@
+import * as React from "react";
+const arrayFormat = (array) => array.map((propType) => propTypeFormat(propType));
+const shapeFormat = (shape) => {
+  const props = Object.keys(shape).map((key) => {
+    const value = shape[key];
+    let valueFormat;
+    if (value.type && (value.type === "arrayOf" || value.type === "oneOfType" || value.type === "oneOf") && Array.isArray(value.args)) {
+      valueFormat = `${propTypeFormat(value)}`;
+    } else if (value.type === "shape") {
+      valueFormat = `${propTypeFormat(value)}`;
+    } else {
+      valueFormat = propTypeFormat(value);
+    }
+    return `${key}${value.reactDesc && value.reactDesc.required ? "" : "?"}: ${valueFormat}`;
+  });
+  return `{${props.join(",")}}`;
+};
+const propTypeFormat = (propType, joinWith = "") => {
+  let result;
+  if (Array.isArray(propType)) {
+    result = arrayFormat(propType).join(joinWith);
+  } else if (typeof propType !== "function" && propType.type) {
+    switch (propType.type) {
+      case "array":
+        result = "any[]";
+        break;
+      case "arrayOf":
+        if (propType.args.type === "oneOfType") {
+          result = `(${propTypeFormat(propType.args, " | ")})[]`;
+        } else {
+          result = `${propTypeFormat(propType.args, "\n")}[]`;
+        }
+        break;
+      case "tuple":
+        result = `[${propTypeFormat(propType.args, ", ")}]`;
+        break;
+      case "bool":
+        result = "boolean";
+        break;
+      case "func":
+        result = "((...args: any[]) => any)";
+        break;
+      case "node":
+        result = "React.ReactNode";
+        break;
+      case "element":
+        result = "JSX.Element";
+        break;
+      case "instanceOf":
+        result = "any";
+        break;
+      case "symbol":
+        result = "any";
+        break;
+      case "objectOf":
+        result = `{ [key: string]: ${propTypeFormat(propType.args)} }`;
+        break;
+      case "oneOf":
+        result = propType.args.map((a) => `"${a}"`).join(" | ");
+        break;
+      case "oneOfType":
+        result = `${propTypeFormat(propType.args, " | ")}`;
+        break;
+      case "shape":
+        result = `${shapeFormat(propType.args)}`;
+        break;
+      default:
+        result = `${propType.type}`;
+        break;
+    }
+  } else {
+    result = "any";
+  }
+  return result;
+};
+const propTypeAsTypescript = (propType, propName) => {
+  const documentation = {
+    ...propType.reactDesc,
+    name: propName
+  };
+  documentation.format = propTypeFormat(propType);
+  return documentation;
+};
+function descToTypescript(component, reactDesc) {
+  if (!component) {
+    throw new Error("react-desc: component is required");
+  }
+  const documentation = {
+    name: component.displayName || component.name,
+    ...reactDesc
+  };
+  if (reactDesc) {
+    delete documentation.propTypes;
+    if (reactDesc.propTypes) {
+      const propTypes = [];
+      Object.keys(reactDesc.propTypes).forEach((propName) => {
+        const propType = reactDesc.propTypes[propName];
+        propTypes.push(propTypeAsTypescript(propType, propName));
+      });
+      if (propTypes.length > 0) {
+        documentation.properties = propTypes;
+      }
+    }
+  }
+  return documentation;
+}
+export {
+  descToTypescript as default
+};
+//# sourceMappingURL=toTypescript.js.map

package/esm/propTypes/toTypescript.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/propTypes/toTypescript.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/restrict-template-expressions */\n/* eslint-disable @typescript-eslint/no-use-before-define */\n/* eslint-disable complexity */\n/* eslint-disable react/forbid-foreign-prop-types */\nimport React from 'react';\nimport { ComponentDocumentation, ReactDescT, TypescriptDocumentation } from './types';\n\nconst arrayFormat = (array: ReactDescT[]) => array.map((propType) => propTypeFormat(propType));\n\nconst shapeFormat = (shape: Record<string, ReactDescT>) => {\n  const props = Object.keys(shape).map((key) => {\n    const value = shape[key];\n    let valueFormat;\n    if (\n      value.type &&\n      (value.type === 'arrayOf' || value.type === 'oneOfType' || value.type === 'oneOf') &&\n      Array.isArray(value.args)\n    ) {\n      valueFormat = `${propTypeFormat(value)}`;\n    } else if (value.type === 'shape') {\n      valueFormat = `${propTypeFormat(value)}`;\n    } else {\n      valueFormat = propTypeFormat(value);\n    }\n    return `${key}${value.reactDesc && value.reactDesc.required ? '' : '?'}: ${valueFormat}`;\n  });\n  return `{${props.join(',')}}`;\n};\n\nconst propTypeFormat = (propType: ReactDescT | ReactDescT[], joinWith = ''): string => {\n  let result;\n  if (Array.isArray(propType)) {\n    result = arrayFormat(propType).join(joinWith);\n  } else if (typeof propType !== 'function' && propType.type) {\n    switch (propType.type) {\n      case 'array':\n        result = 'any[]';\n        break;\n      case 'arrayOf':\n        if ((propType.args as ReactDescT).type === 'oneOfType') {\n          result = `(${propTypeFormat(propType.args as ReactDescT, ' | ')})[]`;\n        } else {\n          result = `${propTypeFormat(propType.args as ReactDescT, '\\n')}[]`;\n        }\n        break;\n      case 'tuple':\n        result = `[${propTypeFormat(propType.args as ReactDescT, ', ')}]`;\n        break;\n      case 'bool':\n        result = 'boolean';\n        break;\n      case 'func':\n        result = '((...args: any[]) => any)';\n        break;\n      case 'node':\n        result = 'React.ReactNode';\n        break;\n      case 'element':\n        result = 'JSX.Element';\n        break;\n      case 'instanceOf':\n        result = 'any';\n        break;\n      case 'symbol':\n        result = 'any';\n        break;\n      case 'objectOf':\n        result = `{ [key: string]: ${propTypeFormat(propType.args as ReactDescT)} }`;\n        break;\n      case 'oneOf':\n        result = (propType.args as unknown[]).map((a) => `\"${a}\"`).join(' | ');\n        break;\n      case 'oneOfType':\n        result = `${propTypeFormat(propType.args as ReactDescT[], ' | ')}`;\n        break;\n      case 'shape':\n        result = `${shapeFormat(propType.args as Record<string, ReactDescT>)}`;\n        break;\n      default:\n        result = `${propType.type}`;\n        break;\n    }\n  } else {\n    result = 'any';\n  }\n  return result;\n};\n\nconst propTypeAsTypescript = (propType: ReactDescT, propName: string) => {\n  const documentation = {\n    ...propType.reactDesc,\n    name: propName,\n  };\n\n  documentation.format = propTypeFormat(propType);\n\n  return documentation;\n};\n\nexport default function descToTypescript<C>(component: React.ComponentType<C>, reactDesc: ComponentDocumentation) {\n  if (!component) {\n    throw new Error('react-desc: component is required');\n  }\n\n  const documentation: TypescriptDocumentation = {\n    name: component.displayName || component.name,\n    ...reactDesc,\n  };\n  if (reactDesc) {\n    delete documentation.propTypes;\n\n    if (reactDesc.propTypes) {\n      const propTypes: TypescriptDocumentation['properties'] = [];\n      Object.keys(reactDesc.propTypes).forEach((propName) => {\n        const propType = reactDesc.propTypes[propName];\n        propTypes.push(propTypeAsTypescript(propType, propName));\n      });\n      if (propTypes.length > 0) {\n        documentation.properties = propTypes;\n      }\n    }\n  }\n  return documentation;\n}\n"],
+  "mappings": "AAAA;ACOA,MAAM,cAAc,CAAC,UAAwB,MAAM,IAAI,CAAC,aAAa,eAAe;AAEpF,MAAM,cAAc,CAAC,UAAsC;AACzD,QAAM,QAAQ,OAAO,KAAK,OAAO,IAAI,CAAC,QAAQ;AAC5C,UAAM,QAAQ,MAAM;AACpB,QAAI;AACJ,QACE,MAAM,QACL,OAAM,SAAS,aAAa,MAAM,SAAS,eAAe,MAAM,SAAS,YAC1E,MAAM,QAAQ,MAAM,OACpB;AACA,oBAAc,GAAG,eAAe;AAAA,eACvB,MAAM,SAAS,SAAS;AACjC,oBAAc,GAAG,eAAe;AAAA,WAC3B;AACL,oBAAc,eAAe;AAAA;AAE/B,WAAO,GAAG,MAAM,MAAM,aAAa,MAAM,UAAU,WAAW,KAAK,QAAQ;AAAA;AAE7E,SAAO,IAAI,MAAM,KAAK;AAAA;AAGxB,MAAM,iBAAiB,CAAC,UAAqC,WAAW,OAAe;AACrF,MAAI;AACJ,MAAI,MAAM,QAAQ,WAAW;AAC3B,aAAS,YAAY,UAAU,KAAK;AAAA,aAC3B,OAAO,aAAa,cAAc,SAAS,MAAM;AAC1D,YAAQ,SAAS;AAAA,WACV;AACH,iBAAS;AACT;AAAA,WACG;AACH,YAAK,SAAS,KAAoB,SAAS,aAAa;AACtD,mBAAS,IAAI,eAAe,SAAS,MAAoB;AAAA,eACpD;AACL,mBAAS,GAAG,eAAe,SAAS,MAAoB;AAAA;AAE1D;AAAA,WACG;AACH,iBAAS,IAAI,eAAe,SAAS,MAAoB;AACzD;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS;AACT;AAAA,WACG;AACH,iBAAS,oBAAoB,eAAe,SAAS;AACrD;AAAA,WACG;AACH,iBAAU,SAAS,KAAmB,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK;AAChE;AAAA,WACG;AACH,iBAAS,GAAG,eAAe,SAAS,MAAsB;AAC1D;AAAA,WACG;AACH,iBAAS,GAAG,YAAY,SAAS;AACjC;AAAA;AAEA,iBAAS,GAAG,SAAS;AACrB;AAAA;AAAA,SAEC;AACL,aAAS;AAAA;AAEX,SAAO;AAAA;AAGT,MAAM,uBAAuB,CAAC,UAAsB,aAAqB;AACvE,QAAM,gBAAgB;AAAA,OACjB,SAAS;AAAA,IACZ,MAAM;AAAA;AAGR,gBAAc,SAAS,eAAe;AAEtC,SAAO;AAAA;AAGM,0BAA6B,WAAmC,WAAmC;AAChH,MAAI,CAAC,WAAW;AACd,UAAM,IAAI,MAAM;AAAA;AAGlB,QAAM,gBAAyC;AAAA,IAC7C,MAAM,UAAU,eAAe,UAAU;AAAA,OACtC;AAAA;AAEL,MAAI,WAAW;AACb,WAAO,cAAc;AAErB,QAAI,UAAU,WAAW;AACvB,YAAM,YAAmD;AACzD,aAAO,KAAK,UAAU,WAAW,QAAQ,CAAC,aAAa;AACrD,cAAM,WAAW,UAAU,UAAU;AACrC,kBAAU,KAAK,qBAAqB,UAAU;AAAA;AAEhD,UAAI,UAAU,SAAS,GAAG;AACxB,sBAAc,aAAa;AAAA;AAAA;AAAA;AAIjC,SAAO;AAAA;",
+  "names": []
+}

package/esm/propTypes/types.js

@@ -0,0 +1,2 @@
+import * as React from "react";
+//# sourceMappingURL=types.js.map

package/esm/propTypes/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n"],
+  "mappings": "AAAA;",
+  "names": []
+}

package/esm/tests/globalProps/TestComponent.js

@@ -0,0 +1,13 @@
+import * as React from "react";
+import React2 from "react";
+import { useGetGlobalAttributes } from "../../globalProps";
+const TestComponent = (props) => {
+  const globalAttributes = useGetGlobalAttributes(props);
+  return /* @__PURE__ */ React2.createElement("div", {
+    ...globalAttributes
+  }, "Some random div");
+};
+export {
+  TestComponent
+};
+//# sourceMappingURL=TestComponent.js.map

package/esm/tests/globalProps/TestComponent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/tests/globalProps/TestComponent.js"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import React from 'react';\nimport { useGetGlobalAttributes } from '../../globalProps';\n\nexport const TestComponent = (props) => {\n  const globalAttributes = useGetGlobalAttributes(props);\n\n  return <div {...globalAttributes}>Some random div</div>;\n};\n"],
+  "mappings": "AAAA;ACAA;AACA;AAEO,MAAM,gBAAgB,CAAC,UAAU;AACtC,QAAM,mBAAmB,uBAAuB;AAEhD,SAAO,qCAAC,OAAD;AAAA,OAAS;AAAA,KAAkB;AAAA;",
+  "names": []
+}

package/esm/tests/{test.schema.js.map → validation/test.schema.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/tests/test.schema.js"],
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/tests/validation/test.schema.js"],
   "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { PropTypes, describe } from 'react-desc';\n\nconst TestSchema = {\n  string: PropTypes.string.description('String'),\n  number: PropTypes.number.description('Number'),\n  boolean: PropTypes.bool.description('Boolean'),\n  any: PropTypes.any.description('Any'),\n  union: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('Union'),\n  union2: PropTypes.oneOf(['A', 'B']).description('Union 2'),\n  union3: PropTypes.oneOfType([\n    PropTypes.string,\n    PropTypes.arrayOf(PropTypes.string),\n    PropTypes.shape({ string: PropTypes.string }),\n  ]).description('Union 3'),\n  array: PropTypes.arrayOf(PropTypes.string).description('Array'),\n  object: PropTypes.object.description('Object'),\n  shape: PropTypes.shape({\n    string: PropTypes.string.description('String').isRequired,\n    number: PropTypes.number.description('Number'),\n    boolean: PropTypes.bool.description('Boolean'),\n    anotherShape: PropTypes.shape({\n      string: PropTypes.string.description('String').isRequired,\n      number: PropTypes.number.description('Number'),\n      boolean: PropTypes.bool.description('Boolean'),\n    }).description('Another shape'),\n  }).description('Shape'),\n  function: PropTypes.func.description('Function'),\n  jsx: PropTypes.element.description('JSX'),\n  node: PropTypes.node.description('Node'),\n};\n\nconst TestComponent = () => null;\n\nconst TestComponentWithSchema = describe(TestComponent).description('Test Component');\n\nTestComponentWithSchema.propTypes = TestSchema;\n\nexport const TypescriptSchema = TestComponentWithSchema.toTypescript();\n"],
   "mappings": "AAAA;ACAA;AAEA,MAAM,aAAa;AAAA,EACjB,QAAQ,UAAU,OAAO,YAAY;AAAA,EACrC,QAAQ,UAAU,OAAO,YAAY;AAAA,EACrC,SAAS,UAAU,KAAK,YAAY;AAAA,EACpC,KAAK,UAAU,IAAI,YAAY;AAAA,EAC/B,OAAO,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,SAAS,YAAY;AAAA,EAC7E,QAAQ,UAAU,MAAM,CAAC,KAAK,MAAM,YAAY;AAAA,EAChD,QAAQ,UAAU,UAAU;AAAA,IAC1B,UAAU;AAAA,IACV,UAAU,QAAQ,UAAU;AAAA,IAC5B,UAAU,MAAM,EAAE,QAAQ,UAAU;AAAA,KACnC,YAAY;AAAA,EACf,OAAO,UAAU,QAAQ,UAAU,QAAQ,YAAY;AAAA,EACvD,QAAQ,UAAU,OAAO,YAAY;AAAA,EACrC,OAAO,UAAU,MAAM;AAAA,IACrB,QAAQ,UAAU,OAAO,YAAY,UAAU;AAAA,IAC/C,QAAQ,UAAU,OAAO,YAAY;AAAA,IACrC,SAAS,UAAU,KAAK,YAAY;AAAA,IACpC,cAAc,UAAU,MAAM;AAAA,MAC5B,QAAQ,UAAU,OAAO,YAAY,UAAU;AAAA,MAC/C,QAAQ,UAAU,OAAO,YAAY;AAAA,MACrC,SAAS,UAAU,KAAK,YAAY;AAAA,OACnC,YAAY;AAAA,KACd,YAAY;AAAA,EACf,UAAU,UAAU,KAAK,YAAY;AAAA,EACrC,KAAK,UAAU,QAAQ,YAAY;AAAA,EACnC,MAAM,UAAU,KAAK,YAAY;AAAA;AAGnC,MAAM,gBAAgB,MAAM;AAE5B,MAAM,0BAA0B,SAAS,eAAe,YAAY;AAEpE,wBAAwB,YAAY;AAE7B,MAAM,mBAAmB,wBAAwB;",
   "names": []

package/esm/validation/typescriptValidator.js

@@ -1,6 +1,6 @@
 import * as React from "react";
-import { describe } from "react-desc";
 import { useMemo, useState } from "react";
+import { describe } from "../propTypes";
 import { throwRequiredError, throwTypeError } from "./errorTemplates";
 import {
   isArray,

package/esm/validation/typescriptValidator.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/validation/typescriptValidator.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable complexity */\n/* eslint-disable max-lines */\n/* eslint-disable max-params */\nimport { describe } from 'react-desc';\nimport React, { PropsWithChildren, useMemo, useState } from 'react';\nimport { throwRequiredError, throwTypeError } from './errorTemplates';\nimport {\n  isArray,\n  isFunction,\n  isJSXorNode,\n  isObject,\n  isPrimitiveType,\n  isSomethingWithParenthesis,\n  isString,\n  isUnion,\n  isUndefined,\n  isNull,\n} from './typescriptGuards';\nimport { typescriptObjectParser } from './typescriptParsers';\n\ninterface TypescriptSchema {\n  description: string;\n  name: string;\n  properties: { name: string; description: string; defaultValue?: unknown; format: string; required?: boolean }[];\n}\n\ntype ValidatorFn = (\n  schemaName: string,\n  key: string,\n  value: unknown,\n  format: string,\n  validationsMemo: Record<symbol, string>,\n  nextValidationsMemo: Record<symbol, string>,\n) => void;\n\n// =============================================================================\n// Atom Validators\n// =============================================================================\n\n// This functions will validate something from the data\n// and optionally recursively apply `validateValueWithFormat`\n// in smaller parts\n\nconst validateUndefined: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== undefined || value === 'undefined') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\nconst validateNull: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== null || value === 'null') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\nconst validatePrimitiveType: ValidatorFn = (schemaName, key, value, format) => {\n  if (typeof value !== format) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateString: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== format.slice(1, -1)) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateArray: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  // Check that we have an array\n  if (!Array.isArray(value)) {\n    throwTypeError(schemaName, key, value, format);\n  }\n\n  // Check that each element inside satisfies the format\n  (value as unknown[]).forEach((val, index) => {\n    // this is a recursive func, we need to invoke it before it's defined.\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    validateValueWithFormat(\n      schemaName,\n      `${key}[${index}]`,\n      val,\n      format.slice(0, -2),\n      validationsMemo,\n      nextValidationsMemo,\n    );\n  });\n};\nfunction isObjectType(value: unknown | Record<string, unknown>): value is Record<string, unknown> {\n  return !(typeof value !== 'object' || Array.isArray(value));\n}\nconst validateObject: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  const valuesIsObject = isObjectType(value);\n  // Check that we have an object\n  if (!valuesIsObject) {\n    throwTypeError(schemaName, key, value, format);\n    return;\n  }\n\n  if (format === 'object') return;\n\n  const keyValuePairs = typescriptObjectParser(format);\n  // Now we have the key - value pairs\n  // Each key could either be required or not\n  // Just recursively check the object\n\n  keyValuePairs.forEach(([objectKey, objectValue]) => {\n    const trueKey = objectKey.slice(-1) === '?' ? objectKey.slice(0, -1) : objectKey;\n\n    if (trueKey === objectKey && !(trueKey in value)) {\n      throwRequiredError(schemaName, key);\n    }\n\n    if (trueKey in value) {\n      // this is a recursive func, we need to invoke it before it's defined.\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      validateValueWithFormat(\n        schemaName,\n        `${key}[${trueKey}]`,\n        value[trueKey],\n        objectValue,\n        validationsMemo,\n        nextValidationsMemo,\n      );\n    }\n  });\n};\n\nconst validateUnion: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  const possibilities = format.split(/\\s?\\|\\s?/);\n\n  const errors = [];\n\n  possibilities.forEach((possibility) => {\n    try {\n      // this is a recursive func, we need to invoke it before it's defined.\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      validateValueWithFormat(schemaName, key, value, possibility, validationsMemo, nextValidationsMemo);\n    } catch (e) {\n      errors.push(e);\n    }\n  });\n\n  if (errors.length === possibilities.length) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateFunction: ValidatorFn = (schemaName, key, value, format) => {\n  // Check that we have a function\n  if (typeof value !== 'function') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nfunction isJSXElement(value: unknown | JSX.Element): value is JSX.Element {\n  return value === null || (typeof value === 'object' && value !== null && '$$typeof' in value);\n}\nconst validateJSXorNode: ValidatorFn = (schemaName, key, value, format) => {\n  const valueIsJSX = isJSXElement(value);\n  if (format === 'JSX.Element' && !valueIsJSX) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\n// =============================================================================\n// Schema validator\n// =============================================================================\n\nconst validateValueWithFormat: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  nextValidationsMemo[value as symbol] = format;\n\n  if ((value as symbol) in validationsMemo) {\n    // We already validated this value on this format\n    return;\n  }\n\n  if (isUndefined(format)) {\n    validateUndefined(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isNull(format)) {\n    validateNull(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isPrimitiveType(format)) {\n    validatePrimitiveType(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isUnion(format)) {\n    validateUnion(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isString(format)) {\n    validateString(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isArray(format)) {\n    validateArray(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isObject(format)) {\n    validateObject(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isFunction(format)) {\n    validateFunction(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isJSXorNode(format)) {\n    validateJSXorNode(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isSomethingWithParenthesis(format)) {\n    validateValueWithFormat(schemaName, key, value, format.slice(1, -1), validationsMemo, nextValidationsMemo);\n  }\n};\n\nexport const validateTypescriptPropTypesImplementation = (\n  props: PropsWithChildren<Record<string, unknown>>,\n  schema: TypescriptSchema,\n  validationsMemo: Record<string, string> = {},\n  nextValidationsMemo: Record<string, string> = {},\n): void => {\n  const { properties, name: schemaName } = schema;\n\n  properties.forEach((property) => {\n    const { name, format, required } = property;\n\n    if (required && !(name in props)) {\n      throwRequiredError(schema.name, name);\n    }\n\n    if (name in props && (props[name] !== undefined || required)) {\n      validateValueWithFormat(schemaName, name, props[name], format, validationsMemo, nextValidationsMemo);\n    }\n  });\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const useValidateTypescriptPropTypes = <T = Record<string, any>>(\n  props: PropsWithChildren<T>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  propTypes: any,\n): void => {\n  const [validationsMemo, setValidationsMemo] = useState({});\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const ComponentWithSchema = useMemo(() => {\n    const Component = () => {};\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n    return describe(Component);\n  }, []);\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,  @typescript-eslint/no-unsafe-assignment\n  ComponentWithSchema.propTypes = propTypes;\n\n  useMemo(() => {\n    const nextValidationsMemo = {};\n\n    validateTypescriptPropTypesImplementation(\n      props,\n      // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call\n      ComponentWithSchema.toTypescript(),\n      validationsMemo,\n      nextValidationsMemo,\n    );\n\n    setValidationsMemo(nextValidationsMemo);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [props]);\n};\n"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable complexity */\n/* eslint-disable max-lines */\n/* eslint-disable max-params */\nimport React, { PropsWithChildren, useMemo, useState } from 'react';\nimport { describe } from '../propTypes';\nimport { throwRequiredError, throwTypeError } from './errorTemplates';\nimport {\n  isArray,\n  isFunction,\n  isJSXorNode,\n  isObject,\n  isPrimitiveType,\n  isSomethingWithParenthesis,\n  isString,\n  isUnion,\n  isUndefined,\n  isNull,\n} from './typescriptGuards';\nimport { typescriptObjectParser } from './typescriptParsers';\n\ninterface TypescriptSchema {\n  description: string;\n  name: string;\n  properties: { name: string; description: string; defaultValue?: unknown; format: string; required?: boolean }[];\n}\n\ntype ValidatorFn = (\n  schemaName: string,\n  key: string,\n  value: unknown,\n  format: string,\n  validationsMemo: Record<symbol, string>,\n  nextValidationsMemo: Record<symbol, string>,\n) => void;\n\n// =============================================================================\n// Atom Validators\n// =============================================================================\n\n// This functions will validate something from the data\n// and optionally recursively apply `validateValueWithFormat`\n// in smaller parts\n\nconst validateUndefined: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== undefined || value === 'undefined') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\nconst validateNull: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== null || value === 'null') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\nconst validatePrimitiveType: ValidatorFn = (schemaName, key, value, format) => {\n  if (typeof value !== format) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateString: ValidatorFn = (schemaName, key, value, format) => {\n  if (value !== format.slice(1, -1)) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateArray: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  // Check that we have an array\n  if (!Array.isArray(value)) {\n    throwTypeError(schemaName, key, value, format);\n  }\n\n  // Check that each element inside satisfies the format\n  (value as unknown[]).forEach((val, index) => {\n    // this is a recursive func, we need to invoke it before it's defined.\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    validateValueWithFormat(\n      schemaName,\n      `${key}[${index}]`,\n      val,\n      format.slice(0, -2),\n      validationsMemo,\n      nextValidationsMemo,\n    );\n  });\n};\nfunction isObjectType(value: unknown | Record<string, unknown>): value is Record<string, unknown> {\n  return !(typeof value !== 'object' || Array.isArray(value));\n}\nconst validateObject: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  const valuesIsObject = isObjectType(value);\n  // Check that we have an object\n  if (!valuesIsObject) {\n    throwTypeError(schemaName, key, value, format);\n    return;\n  }\n\n  if (format === 'object') return;\n\n  const keyValuePairs = typescriptObjectParser(format);\n  // Now we have the key - value pairs\n  // Each key could either be required or not\n  // Just recursively check the object\n\n  keyValuePairs.forEach(([objectKey, objectValue]) => {\n    const trueKey = objectKey.slice(-1) === '?' ? objectKey.slice(0, -1) : objectKey;\n\n    if (trueKey === objectKey && !(trueKey in value)) {\n      throwRequiredError(schemaName, key);\n    }\n\n    if (trueKey in value) {\n      // this is a recursive func, we need to invoke it before it's defined.\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      validateValueWithFormat(\n        schemaName,\n        `${key}[${trueKey}]`,\n        value[trueKey],\n        objectValue,\n        validationsMemo,\n        nextValidationsMemo,\n      );\n    }\n  });\n};\n\nconst validateUnion: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  const possibilities = format.split(/\\s?\\|\\s?/);\n\n  const errors = [];\n\n  possibilities.forEach((possibility) => {\n    try {\n      // this is a recursive func, we need to invoke it before it's defined.\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      validateValueWithFormat(schemaName, key, value, possibility, validationsMemo, nextValidationsMemo);\n    } catch (e) {\n      errors.push(e);\n    }\n  });\n\n  if (errors.length === possibilities.length) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nconst validateFunction: ValidatorFn = (schemaName, key, value, format) => {\n  // Check that we have a function\n  if (typeof value !== 'function') {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\nfunction isJSXElement(value: unknown | JSX.Element): value is JSX.Element {\n  return value === null || (typeof value === 'object' && value !== null && '$$typeof' in value);\n}\nconst validateJSXorNode: ValidatorFn = (schemaName, key, value, format) => {\n  const valueIsJSX = isJSXElement(value);\n  if (format === 'JSX.Element' && !valueIsJSX) {\n    throwTypeError(schemaName, key, value, format);\n  }\n};\n\n// =============================================================================\n// Schema validator\n// =============================================================================\n\nconst validateValueWithFormat: ValidatorFn = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {\n  nextValidationsMemo[value as symbol] = format;\n\n  if ((value as symbol) in validationsMemo) {\n    // We already validated this value on this format\n    return;\n  }\n\n  if (isUndefined(format)) {\n    validateUndefined(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isNull(format)) {\n    validateNull(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isPrimitiveType(format)) {\n    validatePrimitiveType(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isUnion(format)) {\n    validateUnion(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isString(format)) {\n    validateString(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isArray(format)) {\n    validateArray(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isObject(format)) {\n    validateObject(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isFunction(format)) {\n    validateFunction(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isJSXorNode(format)) {\n    validateJSXorNode(schemaName, key, value, format, validationsMemo, nextValidationsMemo);\n  } else if (isSomethingWithParenthesis(format)) {\n    validateValueWithFormat(schemaName, key, value, format.slice(1, -1), validationsMemo, nextValidationsMemo);\n  }\n};\n\nexport const validateTypescriptPropTypesImplementation = (\n  props: PropsWithChildren<Record<string, unknown>>,\n  schema: TypescriptSchema,\n  validationsMemo: Record<string, string> = {},\n  nextValidationsMemo: Record<string, string> = {},\n): void => {\n  const { properties, name: schemaName } = schema;\n\n  properties.forEach((property) => {\n    const { name, format, required } = property;\n\n    if (required && !(name in props)) {\n      throwRequiredError(schema.name, name);\n    }\n\n    if (name in props && (props[name] !== undefined || required)) {\n      validateValueWithFormat(schemaName, name, props[name], format, validationsMemo, nextValidationsMemo);\n    }\n  });\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const useValidateTypescriptPropTypes = <T = Record<string, any>>(\n  props: PropsWithChildren<T>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  propTypes: any,\n): void => {\n  const [validationsMemo, setValidationsMemo] = useState({});\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const ComponentWithSchema = useMemo(() => {\n    const Component = () => {};\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n    return describe(Component);\n  }, []);\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,  @typescript-eslint/no-unsafe-assignment\n  ComponentWithSchema.propTypes = propTypes;\n\n  useMemo(() => {\n    const nextValidationsMemo = {};\n\n    validateTypescriptPropTypesImplementation(\n      props,\n      // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call\n      ComponentWithSchema.toTypescript(),\n      validationsMemo,\n      nextValidationsMemo,\n    );\n\n    setValidationsMemo(nextValidationsMemo);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [props]);\n};\n"],
   "mappings": "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",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-props-helpers",
-  "version": "2.3.0-alpha.2",
+  "version": "2.3.0-alpha.3",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Props Helpers",
   "module": "./esm/index.js",
@@ -35,9 +35,61 @@
       "import": "./esm/validation/errorTemplates.js",
       "require": "./cjs/validation/errorTemplates.js"
     },
-    "./tests/test.schema": {
-      "import": "./esm/tests/test.schema.js",
-      "require": "./cjs/tests/test.schema.js"
+    "./tests/validation/test.schema": {
+      "import": "./esm/tests/validation/test.schema.js",
+      "require": "./cjs/tests/validation/test.schema.js"
+    },
+    "./tests/globalProps/TestComponent": {
+      "import": "./esm/tests/globalProps/TestComponent.js",
+      "require": "./cjs/tests/globalProps/TestComponent.js"
+    },
+    "./propTypes/types": {
+      "import": "./esm/propTypes/types.js",
+      "require": "./cjs/propTypes/types.js"
+    },
+    "./propTypes/toTypescript": {
+      "import": "./esm/propTypes/toTypescript.js",
+      "require": "./cjs/propTypes/toTypescript.js"
+    },
+    "./propTypes/PropTypes": {
+      "import": "./esm/propTypes/PropTypes.js",
+      "require": "./cjs/propTypes/PropTypes.js"
+    },
+    "./propTypes": {
+      "import": "./esm/propTypes/index.js",
+      "require": "./cjs/propTypes/index.js"
+    },
+    "./propTypes/describeGuards": {
+      "import": "./esm/propTypes/describeGuards.js",
+      "require": "./cjs/propTypes/describeGuards.js"
+    },
+    "./propTypes/describeConversions": {
+      "import": "./esm/propTypes/describeConversions.js",
+      "require": "./cjs/propTypes/describeConversions.js"
+    },
+    "./propTypes/describe": {
+      "import": "./esm/propTypes/describe.js",
+      "require": "./cjs/propTypes/describe.js"
+    },
+    "./propTypes/customPropTypes": {
+      "import": "./esm/propTypes/customPropTypes.js",
+      "require": "./cjs/propTypes/customPropTypes.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",

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>;