@elliemae/ds-decision-graph 3.22.0-next.26

package/dist/cjs/DSDecisionGraph.js

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DSDecisionGraph_exports = {};
+__export(DSDecisionGraph_exports, {
+  DSDecisionGraph: () => DSDecisionGraph,
+  DSDecisionGraphWithSchema: () => DSDecisionGraphWithSchema
+});
+module.exports = __toCommonJS(DSDecisionGraph_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_ds_system = require("@elliemae/ds-system");
+var import_ds_grid = require("@elliemae/ds-grid");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_useDecisionGraph = require("./config/useDecisionGraph.js");
+var import_constants = require("./constants/index.js");
+var import_MermaidDecisionChart = require("./parts/mermaid/MermaidDecisionChart.js");
+const StyledWrapper = (0, import_ds_system.styled)(import_ds_grid.Grid, { name: "ds-decision-graph", slot: import_constants.DECISION_GRAPH_SLOTS.WRAPPER })``;
+const mainContentCols = ["1fr"];
+const getOwnerPropsArgumentsNoOp = () => ({});
+const DSDecisionGraph = (props) => {
+  const { propsWithDefault, globalProps, xstyledProps, instanceUid } = (0, import_useDecisionGraph.useDecisionGraph)(props);
+  const getOwnerProps = import_react.default.useCallback(() => propsWithDefault, [propsWithDefault]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    StyledWrapper,
+    {
+      cols: mainContentCols,
+      getOwnerProps,
+      getOwnerPropsArguments: getOwnerPropsArgumentsNoOp,
+      ...globalProps,
+      ...xstyledProps,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_MermaidDecisionChart.MermaidDecisionChart,
+        {
+          uid: instanceUid,
+          chartJson: propsWithDefault.chartJson,
+          direction: propsWithDefault.direction
+        }
+      )
+    }
+  );
+};
+DSDecisionGraph.displayName = import_constants.DSDecisionGraphName;
+const DSDecisionGraphWithSchema = (0, import_ds_props_helpers.describe)(DSDecisionGraph);
+DSDecisionGraphWithSchema.propTypes = import_react_desc_prop_types.DSDecisionGraphPropTypesSchema;
+//# sourceMappingURL=DSDecisionGraph.js.map

package/dist/cjs/DSDecisionGraph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSDecisionGraph.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport { describe } from '@elliemae/ds-props-helpers';\nimport { styled } from '@elliemae/ds-system';\nimport { Grid } from '@elliemae/ds-grid';\nimport { type DSDecisionGraphT, DSDecisionGraphPropTypesSchema } from './react-desc-prop-types.js';\nimport { useDecisionGraph } from './config/useDecisionGraph.js';\nimport { DECISION_GRAPH_SLOTS, DSDecisionGraphName } from './constants/index.js';\nimport { MermaidDecisionChart } from './parts/mermaid/MermaidDecisionChart.js';\n\nconst StyledWrapper = styled(Grid, { name: 'ds-decision-graph', slot: DECISION_GRAPH_SLOTS.WRAPPER })``;\nconst mainContentCols = ['1fr'];\n\nconst getOwnerPropsArgumentsNoOp = () => ({});\nconst DSDecisionGraph: React.ComponentType<DSDecisionGraphT.Props> = (props) => {\n  const { propsWithDefault, globalProps, xstyledProps, instanceUid } = useDecisionGraph(props);\n  const getOwnerProps = React.useCallback(() => propsWithDefault, [propsWithDefault]);\n  return (\n    <StyledWrapper\n      cols={mainContentCols}\n      getOwnerProps={getOwnerProps}\n      getOwnerPropsArguments={getOwnerPropsArgumentsNoOp}\n      {...globalProps}\n      {...xstyledProps}\n    >\n      <MermaidDecisionChart\n        uid={instanceUid}\n        chartJson={propsWithDefault.chartJson}\n        direction={propsWithDefault.direction}\n      />\n    </StyledWrapper>\n  );\n};\n\nDSDecisionGraph.displayName = DSDecisionGraphName;\nconst DSDecisionGraphWithSchema = describe(DSDecisionGraph);\nDSDecisionGraphWithSchema.propTypes = DSDecisionGraphPropTypesSchema;\n\nexport { DSDecisionGraph, DSDecisionGraphWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADwBjB;AAxBN,mBAAkB;AAClB,8BAAyB;AACzB,uBAAuB;AACvB,qBAAqB;AACrB,mCAAsE;AACtE,8BAAiC;AACjC,uBAA0D;AAC1D,kCAAqC;AAErC,MAAM,oBAAgB,yBAAO,qBAAM,EAAE,MAAM,qBAAqB,MAAM,sCAAqB,QAAQ,CAAC;AACpG,MAAM,kBAAkB,CAAC,KAAK;AAE9B,MAAM,6BAA6B,OAAO,CAAC;AAC3C,MAAM,kBAA+D,CAAC,UAAU;AAC9E,QAAM,EAAE,kBAAkB,aAAa,cAAc,YAAY,QAAI,0CAAiB,KAAK;AAC3F,QAAM,gBAAgB,aAAAA,QAAM,YAAY,MAAM,kBAAkB,CAAC,gBAAgB,CAAC;AAClF,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAM;AAAA,MACN;AAAA,MACA,wBAAwB;AAAA,MACvB,GAAG;AAAA,MACH,GAAG;AAAA,MAEJ;AAAA,QAAC;AAAA;AAAA,UACC,KAAK;AAAA,UACL,WAAW,iBAAiB;AAAA,UAC5B,WAAW,iBAAiB;AAAA;AAAA,MAC9B;AAAA;AAAA,EACF;AAEJ;AAEA,gBAAgB,cAAc;AAC9B,MAAM,gCAA4B,kCAAS,eAAe;AAC1D,0BAA0B,YAAY;",
+  "names": ["React"]
+}

package/dist/cjs/config/useDecisionGraph.js

@@ -0,0 +1,62 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDecisionGraph_exports = {};
+__export(useDecisionGraph_exports, {
+  useDecisionGraph: () => useDecisionGraph
+});
+module.exports = __toCommonJS(useDecisionGraph_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_lodash = require("lodash");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_uid = require("uid");
+var import_react_desc_prop_types = require("../react-desc-prop-types.js");
+var import_useValidateProps = require("./useValidateProps.js");
+const useDecisionGraph = (propsFromUser) => {
+  const propsWithDefault = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(propsFromUser, import_react_desc_prop_types.defaultProps);
+  (0, import_useValidateProps.useValidateProps)(propsWithDefault, import_react_desc_prop_types.DSDecisionGraphPropTypes);
+  const globalProps = (0, import_lodash.omit)((0, import_ds_props_helpers.useGetGlobalAttributes)(propsWithDefault), [
+    "cols",
+    "rows",
+    "wrap"
+  ]);
+  const xstyledProps = (0, import_ds_props_helpers.useGetXstyledProps)(propsWithDefault);
+  const { id } = propsWithDefault;
+  const instanceUid = import_react.default.useMemo(() => id || (0, import_uid.uid)(5), [id]);
+  return import_react.default.useMemo(
+    () => ({
+      propsWithDefault,
+      globalProps,
+      xstyledProps,
+      instanceUid
+    }),
+    [propsWithDefault, globalProps, xstyledProps, instanceUid]
+  );
+};
+//# sourceMappingURL=useDecisionGraph.js.map

package/dist/cjs/config/useDecisionGraph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useDecisionGraph.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport { omit } from 'lodash';\nimport { useGetGlobalAttributes, useGetXstyledProps, useMemoMergePropsWithDefault } from '@elliemae/ds-props-helpers';\nimport { uid } from 'uid';\nimport { type DSDecisionGraphT, DSDecisionGraphPropTypes, defaultProps } from '../react-desc-prop-types.js';\nimport { useValidateProps } from './useValidateProps.js';\n\nexport interface DecisionGraphCTX {\n  propsWithDefault: DSDecisionGraphT.InternalProps;\n  globalProps: ReturnType<typeof useGetGlobalAttributes>;\n  xstyledProps: ReturnType<typeof useGetXstyledProps>;\n  instanceUid: string;\n}\n\nexport const useDecisionGraph = (propsFromUser: DSDecisionGraphT.Props) => {\n  // =============================================================================\n  // MERGE WITH DEFAULT AND VALIDATE PROPS\n  // =============================================================================\n  const propsWithDefault = useMemoMergePropsWithDefault<DSDecisionGraphT.InternalProps>(propsFromUser, defaultProps);\n  useValidateProps(propsWithDefault, DSDecisionGraphPropTypes);\n  // =============================================================================\n  // GLOBAL ATTRIBUTES & XSTYLED PROPS\n  // =============================================================================\n  const globalProps = omit(useGetGlobalAttributes<DSDecisionGraphT.InternalProps>(propsWithDefault), [\n    'cols',\n    'rows',\n    'wrap',\n  ]);\n  const xstyledProps = useGetXstyledProps(propsWithDefault);\n  // =============================================================================\n  // AD HOC PER COMPONENT LOGIC\n  // =============================================================================\n  // custom code goes here, this is an example\n  const { id } = propsWithDefault;\n  const instanceUid = React.useMemo(() => id || uid(5), [id]);\n\n  // =============================================================================\n  // HELPERS HOOKS CONFIGS\n  // =============================================================================\n  // const eventHandlers = useEventHandlers({ propsWithDefault, instanceUid }); // <-- complex logic should be made atomics this way\n\n  return React.useMemo(\n    () => ({\n      propsWithDefault,\n      globalProps,\n      xstyledProps,\n      instanceUid,\n    }),\n    [propsWithDefault, globalProps, xstyledProps, instanceUid],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkB;AAClB,oBAAqB;AACrB,8BAAyF;AACzF,iBAAoB;AACpB,mCAA8E;AAC9E,8BAAiC;AAS1B,MAAM,mBAAmB,CAAC,kBAA0C;AAIzE,QAAM,uBAAmB,sDAA6D,eAAe,yCAAY;AACjH,gDAAiB,kBAAkB,qDAAwB;AAI3D,QAAM,kBAAc,wBAAK,gDAAuD,gBAAgB,GAAG;AAAA,IACjG;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,mBAAe,4CAAmB,gBAAgB;AAKxD,QAAM,EAAE,GAAG,IAAI;AACf,QAAM,cAAc,aAAAA,QAAM,QAAQ,MAAM,UAAM,gBAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAO1D,SAAO,aAAAA,QAAM;AAAA,IACX,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,CAAC,kBAAkB,aAAa,cAAc,WAAW;AAAA,EAC3D;AACF;",
+  "names": ["React"]
+}

package/dist/cjs/config/useValidateProps.js

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useValidateProps_exports = {};
+__export(useValidateProps_exports, {
+  useValidateProps: () => useValidateProps
+});
+module.exports = __toCommonJS(useValidateProps_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_constants = require("../constants/index.js");
+var import_ajv = __toESM(require("ajv"));
+const useValidateProps = (props, propTypes) => {
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(props, propTypes, import_constants.DSDecisionGraphName);
+  import_react.default.useEffect(() => {
+    const ajv = new import_ajv.default();
+    const validate = ajv.compile(import_constants.JSON_SCHEMA);
+    const valid = validate(props.chartJson);
+    if (!valid) {
+      throw new Error(`Invalid JSON: ${JSON.stringify(validate.errors)}`);
+    }
+  }, [props.chartJson]);
+};
+//# sourceMappingURL=useValidateProps.js.map

package/dist/cjs/config/useValidateProps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useValidateProps.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport type { WeakValidationMap } from 'react';\nimport { useValidateTypescriptPropTypes } from '@elliemae/ds-props-helpers';\nimport { type DSDecisionGraphT } from '../react-desc-prop-types.js';\nimport { DSDecisionGraphName, JSON_SCHEMA } from '../constants/index.js';\nimport Ajv from 'ajv';\n\nexport const useValidateProps = (\n  props: DSDecisionGraphT.InternalProps,\n  propTypes: WeakValidationMap<unknown>,\n): void => {\n  // we validate the \"required if\" via 'isRequiredIf from our custom PropTypes\n  useValidateTypescriptPropTypes(props, propTypes, DSDecisionGraphName);\n  React.useEffect(() => {\n    const ajv = new Ajv();\n    const validate = ajv.compile(JSON_SCHEMA);\n    const valid = validate(props.chartJson);\n    if (!valid) {\n      throw new Error(`Invalid JSON: ${JSON.stringify(validate.errors)}`);\n    }\n  }, [props.chartJson]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkB;AAElB,8BAA+C;AAE/C,uBAAiD;AACjD,iBAAgB;AAET,MAAM,mBAAmB,CAC9B,OACA,cACS;AAET,8DAA+B,OAAO,WAAW,oCAAmB;AACpE,eAAAA,QAAM,UAAU,MAAM;AACpB,UAAM,MAAM,IAAI,WAAAC,QAAI;AACpB,UAAM,WAAW,IAAI,QAAQ,4BAAW;AACxC,UAAM,QAAQ,SAAS,MAAM,SAAS;AACtC,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,iBAAiB,KAAK,UAAU,SAAS,MAAM,GAAG;AAAA,IACpE;AAAA,EACF,GAAG,CAAC,MAAM,SAAS,CAAC;AACtB;",
+  "names": ["React", "Ajv"]
+}

package/dist/cjs/constants/index.js

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DECISION_GRAPH_DATA_TESTID: () => DECISION_GRAPH_DATA_TESTID,
+  DECISION_GRAPH_SLOTS: () => DECISION_GRAPH_SLOTS,
+  DSDecisionGraphName: () => DSDecisionGraphName,
+  JSON_SCHEMA: () => JSON_SCHEMA
+});
+module.exports = __toCommonJS(constants_exports);
+var React = __toESM(require("react"));
+var import_ds_system = require("@elliemae/ds-system");
+const DSDecisionGraphName = "DSDecisionGraph";
+const DECISION_GRAPH_SLOTS = {
+  WRAPPER: "wrapper"
+};
+const DECISION_GRAPH_DATA_TESTID = (0, import_ds_system.slotObjectToDataTestIds)(DSDecisionGraphName, DECISION_GRAPH_SLOTS);
+const JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    chartTitle: {
+      type: "string",
+      description: "Title of the decision chart"
+    },
+    subtree: {
+      $ref: "#/definitions/DecisionNode",
+      description: "The root of the decision tree"
+    }
+  },
+  required: ["chartTitle", "subtree"],
+  definitions: {
+    DecisionNode: {
+      type: "object",
+      properties: {
+        nodeText: {
+          type: "string",
+          description: "Text representing a conclusion or question"
+        },
+        semanticMeaning: { type: "string", enum: ["question", "conclusion"] },
+        repeatedId: {
+          type: "string",
+          description: "optional unique identifier for the node, used to allow pointing multiple paths to the same node in the chart"
+        },
+        truePath: {
+          $ref: "#/definitions/DecisionNode",
+          description: "Decision node for the true path"
+        },
+        falsePath: {
+          $ref: "#/definitions/DecisionNode",
+          description: "Decision node for the false path"
+        },
+        notApplicablePath: {
+          $ref: "#/definitions/DecisionNode",
+          description: "Decision node for the not applicable path"
+        }
+      },
+      required: ["nodeText", "semanticMeaning"]
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/constants/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/constants/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { slotObjectToDataTestIds } from '@elliemae/ds-system';\n// carefull to not implement dependency cycles, especially in react-desc-prop-types.ts\n// this file is meant to host \"simple\" constants\n// this file should never need to refeer the typescript namespace\n// if you need the typescript namespace in this file, you are probably not having to define a constant ?\n// if you are sure it's actually a constant declare a new file like `complex-constants.ts` or something like that to avoid cycle\n\nexport const DSDecisionGraphName = 'DSDecisionGraph';\n\n// we are giving \"component_name_slots\" to avoid errors on duplicate exports variables in aggregators\nexport const DECISION_GRAPH_SLOTS = {\n  WRAPPER: 'wrapper',\n} as const;\n\n// we are giving \"component_name_data_testid\" to avoid errors on duplicate exports variables in aggregators\nexport const DECISION_GRAPH_DATA_TESTID = slotObjectToDataTestIds(DSDecisionGraphName, DECISION_GRAPH_SLOTS);\n\nexport const JSON_SCHEMA = {\n  $schema: 'http://json-schema.org/draft-07/schema#',\n  type: 'object',\n  properties: {\n    chartTitle: {\n      type: 'string',\n      description: 'Title of the decision chart',\n    },\n    subtree: {\n      $ref: '#/definitions/DecisionNode',\n      description: 'The root of the decision tree',\n    },\n  },\n  required: ['chartTitle', 'subtree'],\n  definitions: {\n    DecisionNode: {\n      type: 'object',\n      properties: {\n        nodeText: {\n          type: 'string',\n          description: 'Text representing a conclusion or question',\n        },\n        semanticMeaning: { type: 'string', enum: ['question', 'conclusion'] },\n        repeatedId: {\n          type: 'string',\n          description:\n            'optional unique identifier for the node, used to allow pointing multiple paths to the same node in the chart',\n        },\n        truePath: {\n          $ref: '#/definitions/DecisionNode',\n          description: 'Decision node for the true path',\n        },\n        falsePath: {\n          $ref: '#/definitions/DecisionNode',\n          description: 'Decision node for the false path',\n        },\n        notApplicablePath: {\n          $ref: '#/definitions/DecisionNode',\n          description: 'Decision node for the not applicable path',\n        },\n      },\n      required: ['nodeText', 'semanticMeaning'],\n    },\n  },\n} as const;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,uBAAwC;AAOjC,MAAM,sBAAsB;AAG5B,MAAM,uBAAuB;AAAA,EAClC,SAAS;AACX;AAGO,MAAM,iCAA6B,0CAAwB,qBAAqB,oBAAoB;AAEpG,MAAM,cAAc;AAAA,EACzB,SAAS;AAAA,EACT,MAAM;AAAA,EACN,YAAY;AAAA,IACV,YAAY;AAAA,MACV,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,IACA,SAAS;AAAA,MACP,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,UAAU,CAAC,cAAc,SAAS;AAAA,EAClC,aAAa;AAAA,IACX,cAAc;AAAA,MACZ,MAAM;AAAA,MACN,YAAY;AAAA,QACV,UAAU;AAAA,UACR,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,iBAAiB,EAAE,MAAM,UAAU,MAAM,CAAC,YAAY,YAAY,EAAE;AAAA,QACpE,YAAY;AAAA,UACV,MAAM;AAAA,UACN,aACE;AAAA,QACJ;AAAA,QACA,UAAU;AAAA,UACR,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,WAAW;AAAA,UACT,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,mBAAmB;AAAA,UACjB,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,MACF;AAAA,MACA,UAAU,CAAC,YAAY,iBAAiB;AAAA,IAC1C;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  DECISION_GRAPH_DATA_TESTID: () => import_constants.DECISION_GRAPH_DATA_TESTID,
+  DECISION_GRAPH_SLOTS: () => import_constants.DECISION_GRAPH_SLOTS,
+  DSDecisionGraph: () => import_DSDecisionGraph.DSDecisionGraph,
+  DSDecisionGraphWithSchema: () => import_DSDecisionGraph.DSDecisionGraphWithSchema
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+var import_DSDecisionGraph = require("./DSDecisionGraph.js");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_constants = require("./constants/index.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["// this is a workaround to typescript error TS2742\n// https://github.com/microsoft/TypeScript/issues/47663\nimport type {} from '@xstyled/system';\nexport { DSDecisionGraph, DSDecisionGraphWithSchema } from './DSDecisionGraph.js';\nexport { type DSDecisionGraphT } from './react-desc-prop-types.js';\nexport { DECISION_GRAPH_SLOTS, DECISION_GRAPH_DATA_TESTID } from './constants/index.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGvB,6BAA2D;AAC3D,mCAAsC;AACtC,uBAAiE;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/parts/mermaid/MermaidDecisionChart.js

@@ -0,0 +1,61 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MermaidDecisionChart_exports = {};
+__export(MermaidDecisionChart_exports, {
+  MermaidDecisionChart: () => MermaidDecisionChart
+});
+module.exports = __toCommonJS(MermaidDecisionChart_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_decisionTreeToMermaidMD = require("./decisionTreeToMermaidMD.js");
+var import_mermaid = __toESM(require("mermaid"));
+const MermaidDecisionChart = (props) => {
+  const { chartJson, uid, direction } = props;
+  const mermaidRef = import_react.default.useRef(null);
+  const mermaidMD = import_react.default.useMemo(() => (0, import_decisionTreeToMermaidMD.decisionTreeToMermaidMD)(chartJson, direction), [chartJson, direction]);
+  import_react.default.useEffect(() => {
+    import_mermaid.default.initialize({
+      startOnLoad: false
+    });
+  }, []);
+  import_react.default.useEffect(() => {
+    setTimeout(() => {
+      const renderAsync = async () => {
+        const { svg } = await import_mermaid.default.render(`mermaid-svg-${uid}`, mermaidMD);
+        if (mermaidRef.current) {
+          mermaidRef.current.innerHTML = svg;
+        }
+      };
+      void renderAsync();
+    }, 0);
+  }, [mermaidMD, uid]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { ref: mermaidRef });
+};
+//# sourceMappingURL=MermaidDecisionChart.js.map

package/dist/cjs/parts/mermaid/MermaidDecisionChart.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/mermaid/MermaidDecisionChart.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport type { DSDecisionGraphT } from '../../react-desc-prop-types.js';\nimport { decisionTreeToMermaidMD } from './decisionTreeToMermaidMD.js';\n// https://github.com/mermaid-js/mermaid/blob/develop/packages/mermaid/src/mermaid.ts#L367\nimport mermaid from 'mermaid';\n\ntype MermaidProps = {\n  chartJson: DSDecisionGraphT.Props['chartJson'];\n  uid: string;\n  direction: DSDecisionGraphT.Directions;\n};\n\nexport const MermaidDecisionChart = (props: MermaidProps) => {\n  const { chartJson, uid, direction } = props;\n  const mermaidRef = React.useRef<HTMLPreElement>(null);\n  // this operation should be O(1), but depending on the size of the decision tree,\n  // it is still potentially beneficial to memoize it...\n  const mermaidMD = React.useMemo(() => decisionTreeToMermaidMD(chartJson, direction), [chartJson, direction]);\n\n  // on mount initialize mermaid\n  React.useEffect(() => {\n    mermaid.initialize({\n      startOnLoad: false,\n    });\n  }, []);\n\n  React.useEffect(() => {\n    setTimeout(() => {\n      const renderAsync = async () => {\n        const { svg } = await mermaid.render(`mermaid-svg-${uid}`, mermaidMD);\n        if (mermaidRef.current) {\n          mermaidRef.current.innerHTML = svg;\n        }\n      };\n      void renderAsync();\n    }, 0);\n  }, [mermaidMD, uid]);\n\n  return <pre ref={mermaidRef} />;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADsCd;AAtCT,mBAAkB;AAElB,qCAAwC;AAExC,qBAAoB;AAQb,MAAM,uBAAuB,CAAC,UAAwB;AAC3D,QAAM,EAAE,WAAW,KAAK,UAAU,IAAI;AACtC,QAAM,aAAa,aAAAA,QAAM,OAAuB,IAAI;AAGpD,QAAM,YAAY,aAAAA,QAAM,QAAQ,UAAM,wDAAwB,WAAW,SAAS,GAAG,CAAC,WAAW,SAAS,CAAC;AAG3G,eAAAA,QAAM,UAAU,MAAM;AACpB,mBAAAC,QAAQ,WAAW;AAAA,MACjB,aAAa;AAAA,IACf,CAAC;AAAA,EACH,GAAG,CAAC,CAAC;AAEL,eAAAD,QAAM,UAAU,MAAM;AACpB,eAAW,MAAM;AACf,YAAM,cAAc,YAAY;AAC9B,cAAM,EAAE,IAAI,IAAI,MAAM,eAAAC,QAAQ,OAAO,eAAe,OAAO,SAAS;AACpE,YAAI,WAAW,SAAS;AACtB,qBAAW,QAAQ,YAAY;AAAA,QACjC;AAAA,MACF;AACA,WAAK,YAAY;AAAA,IACnB,GAAG,CAAC;AAAA,EACN,GAAG,CAAC,WAAW,GAAG,CAAC;AAEnB,SAAO,4CAAC,SAAI,KAAK,YAAY;AAC/B;",
+  "names": ["React", "mermaid"]
+}

package/dist/cjs/parts/mermaid/decisionTreeToMermaidMD.js

@@ -0,0 +1,106 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decisionTreeToMermaidMD_exports = {};
+__export(decisionTreeToMermaidMD_exports, {
+  decisionTreeToMermaidMD: () => decisionTreeToMermaidMD
+});
+module.exports = __toCommonJS(decisionTreeToMermaidMD_exports);
+var React = __toESM(require("react"));
+function nodePathToLinkMarkdown(nodePath) {
+  let linkMarkdown = "";
+  switch (nodePath.charAt(nodePath.length - 1)) {
+    case "t":
+      linkMarkdown = `-->|true|`;
+      break;
+    case "f":
+      linkMarkdown = `-->|false|`;
+      break;
+    case "o":
+      linkMarkdown = `-->|N/A|`;
+      break;
+  }
+  return linkMarkdown;
+}
+function isQuestionText(node) {
+  return (node.semanticMeaning && node.semanticMeaning === "question") ?? false;
+}
+function nodeToMermaidMD(node, nodePath) {
+  let nodeMarkdown;
+  if (isQuestionText(node)) {
+    nodeMarkdown = `${node?.repeatedId ?? nodePath}{{"${node.nodeText}"}}`;
+  } else {
+    nodeMarkdown = `${node?.repeatedId ?? nodePath}("${node.nodeText}")`;
+  }
+  return nodeMarkdown;
+}
+const flatten = (node, decisionNodes, nodePath = "s") => {
+  const decisionNode = {
+    nodeText: node.nodeText,
+    path: nodePath,
+    nodeMarkdown: nodeToMermaidMD(node, nodePath)
+  };
+  decisionNodes.set(nodePath, decisionNode);
+  if (node.truePath) {
+    flatten(node.truePath, decisionNodes, `${nodePath}t`);
+  }
+  if (node.falsePath) {
+    flatten(node.falsePath, decisionNodes, `${nodePath}f`);
+  }
+  if (node.notApplicablePath) {
+    flatten(node.notApplicablePath, decisionNodes, `${nodePath}o`);
+  }
+};
+const flattenDecisionTree = (rootNode) => {
+  const decisionNodes = /* @__PURE__ */ new Map();
+  const treeToFlatten = rootNode.subtree;
+  flatten(treeToFlatten, decisionNodes);
+  return decisionNodes;
+};
+const decisionTreeToMermaidMD = (rootNode, direction = "LR") => {
+  const title = `---
+title: ${rootNode.chartTitle}
+---
+`;
+  let mermaidMD = `${title}flowchart ${direction};
+`;
+  const decisionNodes = flattenDecisionTree(rootNode);
+  decisionNodes.forEach((node, nodePath) => {
+    if (nodePath === "s")
+      return;
+    const parentNodeId = nodePath.slice(0, -1);
+    const parentNode = decisionNodes.get(parentNodeId);
+    if (parentNode) {
+      const linkMarkdown = nodePathToLinkMarkdown(nodePath);
+      mermaidMD += `	${parentNode.nodeMarkdown}${linkMarkdown}${node.nodeMarkdown}
+`;
+    }
+  });
+  return mermaidMD;
+};
+//# sourceMappingURL=decisionTreeToMermaidMD.js.map

package/dist/cjs/parts/mermaid/decisionTreeToMermaidMD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/mermaid/decisionTreeToMermaidMD.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { DSDecisionGraphT } from '../../react-desc-prop-types.js';\n\n/**************************************************************\n ***************** Mermaid Markdown Generator *****************\n ************************************************************ */\n\ntype FlatDecisionNode = {\n  nodeText: string;\n  path: DSDecisionGraphT.NodePath;\n  nodeMarkdown?: DSDecisionGraphT.NodeMarkdown;\n};\nfunction nodePathToLinkMarkdown(nodePath: DSDecisionGraphT.NodePath): DSDecisionGraphT.LinkMarkdown {\n  let linkMarkdown: DSDecisionGraphT.LinkMarkdown = '';\n  switch (nodePath.charAt(nodePath.length - 1)) {\n    case 't':\n      linkMarkdown = `-->|true|`;\n      break;\n    case 'f':\n      linkMarkdown = `-->|false|`;\n      break;\n    case 'o':\n      linkMarkdown = `-->|N/A|`;\n      break;\n  }\n  return linkMarkdown;\n}\nfunction isQuestionText(node: DSDecisionGraphT.DecisionNode): node is DSDecisionGraphT.QuestionNode {\n  return (node.semanticMeaning && node.semanticMeaning === 'question') ?? false;\n}\n\nfunction nodeToMermaidMD(\n  node: DSDecisionGraphT.DecisionNode,\n  nodePath: DSDecisionGraphT.NodePath,\n): DSDecisionGraphT.NodeMarkdown {\n  let nodeMarkdown: DSDecisionGraphT.NodeMarkdown;\n\n  if (isQuestionText(node)) {\n    nodeMarkdown = `${node?.repeatedId ?? nodePath}{{\"${node.nodeText}\"}}`;\n  } else {\n    nodeMarkdown = `${node?.repeatedId ?? nodePath}(\"${node.nodeText}\")`;\n  }\n\n  return nodeMarkdown;\n}\n\n/**\n * Recursively flattens a decision tree node and its children.\n * @param {DSDecisionGraphT.DecisionNode} node - The decision tree node to flatten.\n * @param { Map<DSDecisionGraphT.NodePath, FlatDecisionNode>} decisionNodes - the map to track the flattened nodes.\n * @param {DSDecisionGraphT.NodePath} nodePath - The path of the current node in the decision tree.\n */\nconst flatten = (\n  node: DSDecisionGraphT.DecisionNode,\n  decisionNodes: Map<DSDecisionGraphT.NodePath, FlatDecisionNode>,\n  nodePath: DSDecisionGraphT.NodePath = 's' as DSDecisionGraphT.NodePath,\n) => {\n  const decisionNode: FlatDecisionNode = {\n    nodeText: node.nodeText,\n    path: nodePath,\n    nodeMarkdown: nodeToMermaidMD(node, nodePath),\n  };\n  decisionNodes.set(nodePath, decisionNode);\n  if (node.truePath) {\n    flatten(node.truePath, decisionNodes, `${nodePath}t`);\n  }\n  if (node.falsePath) {\n    flatten(node.falsePath, decisionNodes, `${nodePath}f`);\n  }\n  if (node.notApplicablePath) {\n    flatten(node.notApplicablePath, decisionNodes, `${nodePath}o`);\n  }\n};\n\n/**\n * Flattens a decision tree into a map of flat decision nodes.\n * @param {DSDecisionGraphT.RootNode} rootNode - The root node of the decision tree to flatten.\n * @returns {Map<DSDecisionGraphT.NodePath, FlatDecisionNode>} A map of flat decision nodes, where each node is identified by its node ID.\n */\nconst flattenDecisionTree = (rootNode: DSDecisionGraphT.RootNode): Map<DSDecisionGraphT.NodePath, FlatDecisionNode> => {\n  const decisionNodes: Map<DSDecisionGraphT.NodePath, FlatDecisionNode> = new Map();\n  const treeToFlatten: DSDecisionGraphT.DecisionNode = rootNode.subtree;\n\n  flatten(treeToFlatten, decisionNodes);\n  return decisionNodes;\n};\n\n/**\n * Flattens a decision tree into a map of flat decision nodes.\n * @param {DSDecisionGraphT.RootNode} rootNode - The root node of the decision tree to flatten.\n * @param {DSDecisionGraphT.Directions} direction - direction of the flowchart, default is LR (left to right)\n * @returns {string} A map of flat decision nodes, where each node is identified by its node ID.\n */\nexport const decisionTreeToMermaidMD = (\n  rootNode: DSDecisionGraphT.RootNode,\n  direction: DSDecisionGraphT.Directions = 'LR',\n) => {\n  const title = `---\\ntitle: ${rootNode.chartTitle}\\n---\\n`;\n  let mermaidMD = `${title}flowchart ${direction};\\n`;\n  // let mermaidMD = `flowchart LR;\\n subgraph ${rootNode.chartTitle};\\n`; // this add an highlight to the chart and the title\n  const decisionNodes = flattenDecisionTree(rootNode);\n  decisionNodes.forEach((node, nodePath) => {\n    if (nodePath === 's') return;\n    const parentNodeId = nodePath.slice(0, -1) as DSDecisionGraphT.NodePath;\n    const parentNode = decisionNodes.get(parentNodeId);\n    if (parentNode) {\n      const linkMarkdown = nodePathToLinkMarkdown(nodePath);\n      mermaidMD += `\\t${parentNode.nodeMarkdown}${linkMarkdown}${node.nodeMarkdown}\\n`;\n    }\n  });\n  // mermaidMD += 'end;\\n';\n  return mermaidMD;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADWvB,SAAS,uBAAuB,UAAoE;AAClG,MAAI,eAA8C;AAClD,UAAQ,SAAS,OAAO,SAAS,SAAS,CAAC,GAAG;AAAA,IAC5C,KAAK;AACH,qBAAe;AACf;AAAA,IACF,KAAK;AACH,qBAAe;AACf;AAAA,IACF,KAAK;AACH,qBAAe;AACf;AAAA,EACJ;AACA,SAAO;AACT;AACA,SAAS,eAAe,MAA4E;AAClG,UAAQ,KAAK,mBAAmB,KAAK,oBAAoB,eAAe;AAC1E;AAEA,SAAS,gBACP,MACA,UAC+B;AAC/B,MAAI;AAEJ,MAAI,eAAe,IAAI,GAAG;AACxB,mBAAe,GAAG,MAAM,cAAc,cAAc,KAAK;AAAA,EAC3D,OAAO;AACL,mBAAe,GAAG,MAAM,cAAc,aAAa,KAAK;AAAA,EAC1D;AAEA,SAAO;AACT;AAQA,MAAM,UAAU,CACd,MACA,eACA,WAAsC,QACnC;AACH,QAAM,eAAiC;AAAA,IACrC,UAAU,KAAK;AAAA,IACf,MAAM;AAAA,IACN,cAAc,gBAAgB,MAAM,QAAQ;AAAA,EAC9C;AACA,gBAAc,IAAI,UAAU,YAAY;AACxC,MAAI,KAAK,UAAU;AACjB,YAAQ,KAAK,UAAU,eAAe,GAAG,WAAW;AAAA,EACtD;AACA,MAAI,KAAK,WAAW;AAClB,YAAQ,KAAK,WAAW,eAAe,GAAG,WAAW;AAAA,EACvD;AACA,MAAI,KAAK,mBAAmB;AAC1B,YAAQ,KAAK,mBAAmB,eAAe,GAAG,WAAW;AAAA,EAC/D;AACF;AAOA,MAAM,sBAAsB,CAAC,aAA0F;AACrH,QAAM,gBAAkE,oBAAI,IAAI;AAChF,QAAM,gBAA+C,SAAS;AAE9D,UAAQ,eAAe,aAAa;AACpC,SAAO;AACT;AAQO,MAAM,0BAA0B,CACrC,UACA,YAAyC,SACtC;AACH,QAAM,QAAQ;AAAA,SAAe,SAAS;AAAA;AAAA;AACtC,MAAI,YAAY,GAAG,kBAAkB;AAAA;AAErC,QAAM,gBAAgB,oBAAoB,QAAQ;AAClD,gBAAc,QAAQ,CAAC,MAAM,aAAa;AACxC,QAAI,aAAa;AAAK;AACtB,UAAM,eAAe,SAAS,MAAM,GAAG,EAAE;AACzC,UAAM,aAAa,cAAc,IAAI,YAAY;AACjD,QAAI,YAAY;AACd,YAAM,eAAe,uBAAuB,QAAQ;AACpD,mBAAa,IAAK,WAAW,eAAe,eAAe,KAAK;AAAA;AAAA,IAClE;AAAA,EACF,CAAC;AAED,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/react-desc-prop-types.js

@@ -0,0 +1,54 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_desc_prop_types_exports = {};
+__export(react_desc_prop_types_exports, {
+  DSDecisionGraphPropTypes: () => DSDecisionGraphPropTypes,
+  DSDecisionGraphPropTypesSchema: () => DSDecisionGraphPropTypesSchema,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+var React = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_constants = require("./constants/index.js");
+const defaultProps = {
+  direction: "LR"
+};
+const DSDecisionGraphPropTypes = {
+  ...import_ds_props_helpers.globalAttributesPropTypes,
+  ...import_ds_props_helpers.xstyledPropTypes,
+  chartJson: import_ds_props_helpers.PropTypes.object.description(
+    `the json representing the decision chart. must comply with the following json_schema:
+${JSON.stringify(
+      import_constants.JSON_SCHEMA
+    )}`
+  ).isRequired,
+  direction: import_ds_props_helpers.PropTypes.oneOf(["LR", "TD"]).description("direction of the flowchart, default is LR (left to right)").defaultValue("LR")
+};
+const DSDecisionGraphPropTypesSchema = DSDecisionGraphPropTypes;
+//# sourceMappingURL=react-desc-prop-types.js.map