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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react-desc-prop-types.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport type { GlobalAttributesT, XstyledProps, DSPropTypesSchema } from '@elliemae/ds-props-helpers';\nimport { PropTypes, globalAttributesPropTypes, xstyledPropTypes } from '@elliemae/ds-props-helpers';\nimport type { WeakValidationMap } from 'react';\nimport { JSON_SCHEMA } from './constants/index.js';\n\nexport declare namespace DSDecisionGraphT {\n  export type Directions = 'LR' | 'TD'; // left to right | top down\n  export type SemanticMeaning = 'question' | 'conclusion';\n  export type NodePath = `${string}${'t' | 'f' | 'o' | 's'}`; // Node ID for a decision node, doubles as the path to the node | T true | F false | O (other) not applicable | S start\n  export type ConclusionMarkdown = `${string | NodePath}(${string})`; // Mermaid Markdown for a conclusion node | A node with round edges\n  export type QuestionMarkdown = `${string | NodePath}{{${string}}}`; // Mermaid Markdown for a question node | A hexagon node\n  export type NodeMarkdown = ConclusionMarkdown | QuestionMarkdown;\n  export type TrueLinkMarkdown = `-->|true|`; // Mermaid Markdown for a true path link\n  export type FalseLinkMarkdown = `-->|false|`; // Mermaid Markdown for a false path link\n  export type NALinkMarkdown = `-->|N/A|`; // Mermaid Markdown for a not applicable path link\n  export type LinkMarkdown = TrueLinkMarkdown | FalseLinkMarkdown | NALinkMarkdown | '';\n\n  /**\n   * Node polymorphism for the \"meaning\" the node has in the decision tree.\n   *   this influence the node shape in the decision chart.\n   */\n  // common properties for all nodes\n  export interface BaseNode {\n    nodeText: string; // Text representing a conclusion or question\n    truePath?: DecisionNode; // Decision node for the true path\n    falsePath?: DecisionNode; // Decision node for the false path\n    notApplicablePath?: DecisionNode; // Decision node for the not applicable path\n    repeatedId?: string; // Id of the node if it is repeated in the decision tree and we want to show it only once in the decision chart\n  }\n  // polymorphism for node with the semantic meaning of \"question\"\n  export interface QuestionNode extends BaseNode {\n    semanticMeaning: 'question';\n  }\n  // polymorphism for node with the semantic meaning of \"conclusion\"\n  export interface ConclusionNode extends BaseNode {\n    semanticMeaning: 'conclusion';\n  }\n  // polymorphism for all nodes\n  export type DecisionNode = QuestionNode | ConclusionNode;\n  /**\n   * yes, polymorphism in typescript is this verbose and this hard to handle correctly.\n   */\n\n  export type RootNode = {\n    chartTitle: string; // Title of the decision chart\n    subtree: DecisionNode; // The root of the decision tree\n  };\n\n  export interface RequiredProps {\n    chartJson: RootNode;\n  }\n\n  export interface DefaultProps {\n    direction: Directions;\n  }\n\n  export interface OptionalProps {}\n\n  export interface Props\n    extends Partial<DefaultProps>,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>,\n      XstyledProps,\n      RequiredProps {}\n\n  export interface InternalProps\n    extends DefaultProps,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>,\n      XstyledProps,\n      RequiredProps {}\n}\n\nexport const defaultProps: DSDecisionGraphT.DefaultProps = {\n  direction: 'LR',\n};\n\nexport const DSDecisionGraphPropTypes: DSPropTypesSchema<DSDecisionGraphT.Props> = {\n  ...globalAttributesPropTypes,\n  ...xstyledPropTypes,\n  chartJson: PropTypes.object.description(\n    `the json representing the decision chart. must comply with the following json_schema:\\n${JSON.stringify(\n      JSON_SCHEMA,\n    )}`,\n  ).isRequired,\n  direction: PropTypes.oneOf(['LR', 'TD'])\n    .description('direction of the flowchart, default is LR (left to right)')\n    .defaultValue('LR'),\n};\n\nexport const DSDecisionGraphPropTypesSchema =\n  DSDecisionGraphPropTypes as unknown as WeakValidationMap<DSDecisionGraphT.Props>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGvB,8BAAuE;AAEvE,uBAA4B;AAsErB,MAAM,eAA8C;AAAA,EACzD,WAAW;AACb;AAEO,MAAM,2BAAsE;AAAA,EACjF,GAAG;AAAA,EACH,GAAG;AAAA,EACH,WAAW,kCAAU,OAAO;AAAA,IAC1B;AAAA,EAA0F,KAAK;AAAA,MAC7F;AAAA,IACF;AAAA,EACF,EAAE;AAAA,EACF,WAAW,kCAAU,MAAM,CAAC,MAAM,IAAI,CAAC,EACpC,YAAY,2DAA2D,EACvE,aAAa,IAAI;AACtB;AAEO,MAAM,iCACX;",
+  "names": []
+}

package/dist/esm/DSDecisionGraph.js

@@ -0,0 +1,43 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import React2 from "react";
+import { describe } from "@elliemae/ds-props-helpers";
+import { styled } from "@elliemae/ds-system";
+import { Grid } from "@elliemae/ds-grid";
+import { DSDecisionGraphPropTypesSchema } from "./react-desc-prop-types.js";
+import { useDecisionGraph } from "./config/useDecisionGraph.js";
+import { DECISION_GRAPH_SLOTS, DSDecisionGraphName } from "./constants/index.js";
+import { MermaidDecisionChart } from "./parts/mermaid/MermaidDecisionChart.js";
+const StyledWrapper = styled(Grid, { name: "ds-decision-graph", slot: DECISION_GRAPH_SLOTS.WRAPPER })``;
+const mainContentCols = ["1fr"];
+const getOwnerPropsArgumentsNoOp = () => ({});
+const DSDecisionGraph = (props) => {
+  const { propsWithDefault, globalProps, xstyledProps, instanceUid } = useDecisionGraph(props);
+  const getOwnerProps = React2.useCallback(() => propsWithDefault, [propsWithDefault]);
+  return /* @__PURE__ */ jsx(
+    StyledWrapper,
+    {
+      cols: mainContentCols,
+      getOwnerProps,
+      getOwnerPropsArguments: getOwnerPropsArgumentsNoOp,
+      ...globalProps,
+      ...xstyledProps,
+      children: /* @__PURE__ */ jsx(
+        MermaidDecisionChart,
+        {
+          uid: instanceUid,
+          chartJson: propsWithDefault.chartJson,
+          direction: propsWithDefault.direction
+        }
+      )
+    }
+  );
+};
+DSDecisionGraph.displayName = DSDecisionGraphName;
+const DSDecisionGraphWithSchema = describe(DSDecisionGraph);
+DSDecisionGraphWithSchema.propTypes = DSDecisionGraphPropTypesSchema;
+export {
+  DSDecisionGraph,
+  DSDecisionGraphWithSchema
+};
+//# sourceMappingURL=DSDecisionGraph.js.map

package/dist/esm/DSDecisionGraph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/DSDecisionGraph.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACwBjB;AAxBN,OAAOA,YAAW;AAClB,SAAS,gBAAgB;AACzB,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,SAAgC,sCAAsC;AACtE,SAAS,wBAAwB;AACjC,SAAS,sBAAsB,2BAA2B;AAC1D,SAAS,4BAA4B;AAErC,MAAM,gBAAgB,OAAO,MAAM,EAAE,MAAM,qBAAqB,MAAM,qBAAqB,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,IAAI,iBAAiB,KAAK;AAC3F,QAAM,gBAAgBA,OAAM,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,4BAA4B,SAAS,eAAe;AAC1D,0BAA0B,YAAY;",
+  "names": ["React"]
+}

package/dist/esm/config/useDecisionGraph.js

@@ -0,0 +1,32 @@
+import * as React from "react";
+import React2 from "react";
+import { omit } from "lodash";
+import { useGetGlobalAttributes, useGetXstyledProps, useMemoMergePropsWithDefault } from "@elliemae/ds-props-helpers";
+import { uid } from "uid";
+import { DSDecisionGraphPropTypes, defaultProps } from "../react-desc-prop-types.js";
+import { useValidateProps } from "./useValidateProps.js";
+const useDecisionGraph = (propsFromUser) => {
+  const propsWithDefault = useMemoMergePropsWithDefault(propsFromUser, defaultProps);
+  useValidateProps(propsWithDefault, DSDecisionGraphPropTypes);
+  const globalProps = omit(useGetGlobalAttributes(propsWithDefault), [
+    "cols",
+    "rows",
+    "wrap"
+  ]);
+  const xstyledProps = useGetXstyledProps(propsWithDefault);
+  const { id } = propsWithDefault;
+  const instanceUid = React2.useMemo(() => id || uid(5), [id]);
+  return React2.useMemo(
+    () => ({
+      propsWithDefault,
+      globalProps,
+      xstyledProps,
+      instanceUid
+    }),
+    [propsWithDefault, globalProps, xstyledProps, instanceUid]
+  );
+};
+export {
+  useDecisionGraph
+};
+//# sourceMappingURL=useDecisionGraph.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/config/useDecisionGraph.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,OAAOA,YAAW;AAClB,SAAS,YAAY;AACrB,SAAS,wBAAwB,oBAAoB,oCAAoC;AACzF,SAAS,WAAW;AACpB,SAAgC,0BAA0B,oBAAoB;AAC9E,SAAS,wBAAwB;AAS1B,MAAM,mBAAmB,CAAC,kBAA0C;AAIzE,QAAM,mBAAmB,6BAA6D,eAAe,YAAY;AACjH,mBAAiB,kBAAkB,wBAAwB;AAI3D,QAAM,cAAc,KAAK,uBAAuD,gBAAgB,GAAG;AAAA,IACjG;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,eAAe,mBAAmB,gBAAgB;AAKxD,QAAM,EAAE,GAAG,IAAI;AACf,QAAM,cAAcA,OAAM,QAAQ,MAAM,MAAM,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAO1D,SAAOA,OAAM;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/esm/config/useValidateProps.js

@@ -0,0 +1,20 @@
+import * as React from "react";
+import React2 from "react";
+import { useValidateTypescriptPropTypes } from "@elliemae/ds-props-helpers";
+import { DSDecisionGraphName, JSON_SCHEMA } from "../constants/index.js";
+import Ajv from "ajv";
+const useValidateProps = (props, propTypes) => {
+  useValidateTypescriptPropTypes(props, propTypes, DSDecisionGraphName);
+  React2.useEffect(() => {
+    const ajv = new Ajv();
+    const validate = ajv.compile(JSON_SCHEMA);
+    const valid = validate(props.chartJson);
+    if (!valid) {
+      throw new Error(`Invalid JSON: ${JSON.stringify(validate.errors)}`);
+    }
+  }, [props.chartJson]);
+};
+export {
+  useValidateProps
+};
+//# sourceMappingURL=useValidateProps.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/config/useValidateProps.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,OAAOA,YAAW;AAElB,SAAS,sCAAsC;AAE/C,SAAS,qBAAqB,mBAAmB;AACjD,OAAO,SAAS;AAET,MAAM,mBAAmB,CAC9B,OACA,cACS;AAET,iCAA+B,OAAO,WAAW,mBAAmB;AACpE,EAAAA,OAAM,UAAU,MAAM;AACpB,UAAM,MAAM,IAAI,IAAI;AACpB,UAAM,WAAW,IAAI,QAAQ,WAAW;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"]
+}

package/dist/esm/constants/index.js

@@ -0,0 +1,58 @@
+import * as React from "react";
+import { slotObjectToDataTestIds } from "@elliemae/ds-system";
+const DSDecisionGraphName = "DSDecisionGraph";
+const DECISION_GRAPH_SLOTS = {
+  WRAPPER: "wrapper"
+};
+const DECISION_GRAPH_DATA_TESTID = 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"]
+    }
+  }
+};
+export {
+  DECISION_GRAPH_DATA_TESTID,
+  DECISION_GRAPH_SLOTS,
+  DSDecisionGraphName,
+  JSON_SCHEMA
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/constants/index.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,+BAA+B;AAOjC,MAAM,sBAAsB;AAG5B,MAAM,uBAAuB;AAAA,EAClC,SAAS;AACX;AAGO,MAAM,6BAA6B,wBAAwB,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/esm/index.js

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { DSDecisionGraph, DSDecisionGraphWithSchema } from "./DSDecisionGraph.js";
+import {} from "./react-desc-prop-types.js";
+import { DECISION_GRAPH_SLOTS, DECISION_GRAPH_DATA_TESTID } from "./constants/index.js";
+export {
+  DECISION_GRAPH_DATA_TESTID,
+  DECISION_GRAPH_SLOTS,
+  DSDecisionGraph,
+  DSDecisionGraphWithSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/index.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "// 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"],
+  "mappings": "AAAA,YAAY,WAAW;ACGvB,SAAS,iBAAiB,iCAAiC;AAC3D,eAAsC;AACtC,SAAS,sBAAsB,kCAAkC;",
+  "names": []
+}

package/dist/esm/package.json

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

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

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import React2 from "react";
+import { decisionTreeToMermaidMD } from "./decisionTreeToMermaidMD.js";
+import mermaid from "mermaid";
+const MermaidDecisionChart = (props) => {
+  const { chartJson, uid, direction } = props;
+  const mermaidRef = React2.useRef(null);
+  const mermaidMD = React2.useMemo(() => decisionTreeToMermaidMD(chartJson, direction), [chartJson, direction]);
+  React2.useEffect(() => {
+    mermaid.initialize({
+      startOnLoad: false
+    });
+  }, []);
+  React2.useEffect(() => {
+    setTimeout(() => {
+      const renderAsync = async () => {
+        const { svg } = await mermaid.render(`mermaid-svg-${uid}`, mermaidMD);
+        if (mermaidRef.current) {
+          mermaidRef.current.innerHTML = svg;
+        }
+      };
+      void renderAsync();
+    }, 0);
+  }, [mermaidMD, uid]);
+  return /* @__PURE__ */ jsx("pre", { ref: mermaidRef });
+};
+export {
+  MermaidDecisionChart
+};
+//# sourceMappingURL=MermaidDecisionChart.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/parts/mermaid/MermaidDecisionChart.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACsCd;AAtCT,OAAOA,YAAW;AAElB,SAAS,+BAA+B;AAExC,OAAO,aAAa;AAQb,MAAM,uBAAuB,CAAC,UAAwB;AAC3D,QAAM,EAAE,WAAW,KAAK,UAAU,IAAI;AACtC,QAAM,aAAaA,OAAM,OAAuB,IAAI;AAGpD,QAAM,YAAYA,OAAM,QAAQ,MAAM,wBAAwB,WAAW,SAAS,GAAG,CAAC,WAAW,SAAS,CAAC;AAG3G,EAAAA,OAAM,UAAU,MAAM;AACpB,YAAQ,WAAW;AAAA,MACjB,aAAa;AAAA,IACf,CAAC;AAAA,EACH,GAAG,CAAC,CAAC;AAEL,EAAAA,OAAM,UAAU,MAAM;AACpB,eAAW,MAAM;AACf,YAAM,cAAc,YAAY;AAC9B,cAAM,EAAE,IAAI,IAAI,MAAM,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,oBAAC,SAAI,KAAK,YAAY;AAC/B;",
+  "names": ["React"]
+}

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

@@ -0,0 +1,76 @@
+import * as React from "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;
+};
+export {
+  decisionTreeToMermaidMD
+};
+//# sourceMappingURL=decisionTreeToMermaidMD.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/parts/mermaid/decisionTreeToMermaidMD.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACWvB,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/esm/react-desc-prop-types.js

@@ -0,0 +1,24 @@
+import * as React from "react";
+import { PropTypes, globalAttributesPropTypes, xstyledPropTypes } from "@elliemae/ds-props-helpers";
+import { JSON_SCHEMA } from "./constants/index.js";
+const defaultProps = {
+  direction: "LR"
+};
+const DSDecisionGraphPropTypes = {
+  ...globalAttributesPropTypes,
+  ...xstyledPropTypes,
+  chartJson: PropTypes.object.description(
+    `the json representing the decision chart. must comply with the following json_schema:
+${JSON.stringify(
+      JSON_SCHEMA
+    )}`
+  ).isRequired,
+  direction: PropTypes.oneOf(["LR", "TD"]).description("direction of the flowchart, default is LR (left to right)").defaultValue("LR")
+};
+const DSDecisionGraphPropTypesSchema = DSDecisionGraphPropTypes;
+export {
+  DSDecisionGraphPropTypes,
+  DSDecisionGraphPropTypesSchema,
+  defaultProps
+};
+//# sourceMappingURL=react-desc-prop-types.js.map

package/dist/esm/react-desc-prop-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/react-desc-prop-types.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport type { GlobalAttributesT, XstyledProps, DSPropTypesSchema } from '@elliemae/ds-props-helpers';\nimport { PropTypes, globalAttributesPropTypes, xstyledPropTypes } from '@elliemae/ds-props-helpers';\nimport type { WeakValidationMap } from 'react';\nimport { JSON_SCHEMA } from './constants/index.js';\n\nexport declare namespace DSDecisionGraphT {\n  export type Directions = 'LR' | 'TD'; // left to right | top down\n  export type SemanticMeaning = 'question' | 'conclusion';\n  export type NodePath = `${string}${'t' | 'f' | 'o' | 's'}`; // Node ID for a decision node, doubles as the path to the node | T true | F false | O (other) not applicable | S start\n  export type ConclusionMarkdown = `${string | NodePath}(${string})`; // Mermaid Markdown for a conclusion node | A node with round edges\n  export type QuestionMarkdown = `${string | NodePath}{{${string}}}`; // Mermaid Markdown for a question node | A hexagon node\n  export type NodeMarkdown = ConclusionMarkdown | QuestionMarkdown;\n  export type TrueLinkMarkdown = `-->|true|`; // Mermaid Markdown for a true path link\n  export type FalseLinkMarkdown = `-->|false|`; // Mermaid Markdown for a false path link\n  export type NALinkMarkdown = `-->|N/A|`; // Mermaid Markdown for a not applicable path link\n  export type LinkMarkdown = TrueLinkMarkdown | FalseLinkMarkdown | NALinkMarkdown | '';\n\n  /**\n   * Node polymorphism for the \"meaning\" the node has in the decision tree.\n   *   this influence the node shape in the decision chart.\n   */\n  // common properties for all nodes\n  export interface BaseNode {\n    nodeText: string; // Text representing a conclusion or question\n    truePath?: DecisionNode; // Decision node for the true path\n    falsePath?: DecisionNode; // Decision node for the false path\n    notApplicablePath?: DecisionNode; // Decision node for the not applicable path\n    repeatedId?: string; // Id of the node if it is repeated in the decision tree and we want to show it only once in the decision chart\n  }\n  // polymorphism for node with the semantic meaning of \"question\"\n  export interface QuestionNode extends BaseNode {\n    semanticMeaning: 'question';\n  }\n  // polymorphism for node with the semantic meaning of \"conclusion\"\n  export interface ConclusionNode extends BaseNode {\n    semanticMeaning: 'conclusion';\n  }\n  // polymorphism for all nodes\n  export type DecisionNode = QuestionNode | ConclusionNode;\n  /**\n   * yes, polymorphism in typescript is this verbose and this hard to handle correctly.\n   */\n\n  export type RootNode = {\n    chartTitle: string; // Title of the decision chart\n    subtree: DecisionNode; // The root of the decision tree\n  };\n\n  export interface RequiredProps {\n    chartJson: RootNode;\n  }\n\n  export interface DefaultProps {\n    direction: Directions;\n  }\n\n  export interface OptionalProps {}\n\n  export interface Props\n    extends Partial<DefaultProps>,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>,\n      XstyledProps,\n      RequiredProps {}\n\n  export interface InternalProps\n    extends DefaultProps,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>,\n      XstyledProps,\n      RequiredProps {}\n}\n\nexport const defaultProps: DSDecisionGraphT.DefaultProps = {\n  direction: 'LR',\n};\n\nexport const DSDecisionGraphPropTypes: DSPropTypesSchema<DSDecisionGraphT.Props> = {\n  ...globalAttributesPropTypes,\n  ...xstyledPropTypes,\n  chartJson: PropTypes.object.description(\n    `the json representing the decision chart. must comply with the following json_schema:\\n${JSON.stringify(\n      JSON_SCHEMA,\n    )}`,\n  ).isRequired,\n  direction: PropTypes.oneOf(['LR', 'TD'])\n    .description('direction of the flowchart, default is LR (left to right)')\n    .defaultValue('LR'),\n};\n\nexport const DSDecisionGraphPropTypesSchema =\n  DSDecisionGraphPropTypes as unknown as WeakValidationMap<DSDecisionGraphT.Props>;\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACGvB,SAAS,WAAW,2BAA2B,wBAAwB;AAEvE,SAAS,mBAAmB;AAsErB,MAAM,eAA8C;AAAA,EACzD,WAAW;AACb;AAEO,MAAM,2BAAsE;AAAA,EACjF,GAAG;AAAA,EACH,GAAG;AAAA,EACH,WAAW,UAAU,OAAO;AAAA,IAC1B;AAAA,EAA0F,KAAK;AAAA,MAC7F;AAAA,IACF;AAAA,EACF,EAAE;AAAA,EACF,WAAW,UAAU,MAAM,CAAC,MAAM,IAAI,CAAC,EACpC,YAAY,2DAA2D,EACvE,aAAa,IAAI;AACtB;AAEO,MAAM,iCACX;",
+  "names": []
+}

package/dist/types/DSDecisionGraph.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSDecisionGraphT } from './react-desc-prop-types.js';
+declare const DSDecisionGraph: React.ComponentType<DSDecisionGraphT.Props>;
+declare const DSDecisionGraphWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<DSDecisionGraphT.Props>;
+export { DSDecisionGraph, DSDecisionGraphWithSchema };

package/dist/types/config/useDecisionGraph.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="lodash" />
+import { useGetGlobalAttributes, useGetXstyledProps } from '@elliemae/ds-props-helpers';
+import { type DSDecisionGraphT } from '../react-desc-prop-types.js';
+export interface DecisionGraphCTX {
+    propsWithDefault: DSDecisionGraphT.InternalProps;
+    globalProps: ReturnType<typeof useGetGlobalAttributes>;
+    xstyledProps: ReturnType<typeof useGetXstyledProps>;
+    instanceUid: string;
+}
+export declare const useDecisionGraph: (propsFromUser: DSDecisionGraphT.Props) => {
+    propsWithDefault: DSDecisionGraphT.InternalProps;
+    globalProps: import("lodash").Omit<import("@elliemae/ds-props-helpers").GlobalAttributesT<Element>, "cols" | "rows" | "wrap">;
+    xstyledProps: import("@elliemae/ds-props-helpers").XstyledProps;
+    instanceUid: string;
+};

package/dist/types/config/useValidateProps.d.ts

@@ -0,0 +1,3 @@
+import type { WeakValidationMap } from 'react';
+import { type DSDecisionGraphT } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSDecisionGraphT.InternalProps, propTypes: WeakValidationMap<unknown>) => void;

package/dist/types/constants/index.d.ts

@@ -0,0 +1,52 @@
+export declare const DSDecisionGraphName = "DSDecisionGraph";
+export declare const DECISION_GRAPH_SLOTS: {
+    readonly WRAPPER: "wrapper";
+};
+export declare const DECISION_GRAPH_DATA_TESTID: Record<string, string>;
+export declare const JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly type: "object";
+    readonly properties: {
+        readonly chartTitle: {
+            readonly type: "string";
+            readonly description: "Title of the decision chart";
+        };
+        readonly subtree: {
+            readonly $ref: "#/definitions/DecisionNode";
+            readonly description: "The root of the decision tree";
+        };
+    };
+    readonly required: readonly ["chartTitle", "subtree"];
+    readonly definitions: {
+        readonly DecisionNode: {
+            readonly type: "object";
+            readonly properties: {
+                readonly nodeText: {
+                    readonly type: "string";
+                    readonly description: "Text representing a conclusion or question";
+                };
+                readonly semanticMeaning: {
+                    readonly type: "string";
+                    readonly enum: readonly ["question", "conclusion"];
+                };
+                readonly repeatedId: {
+                    readonly type: "string";
+                    readonly description: "optional unique identifier for the node, used to allow pointing multiple paths to the same node in the chart";
+                };
+                readonly truePath: {
+                    readonly $ref: "#/definitions/DecisionNode";
+                    readonly description: "Decision node for the true path";
+                };
+                readonly falsePath: {
+                    readonly $ref: "#/definitions/DecisionNode";
+                    readonly description: "Decision node for the false path";
+                };
+                readonly notApplicablePath: {
+                    readonly $ref: "#/definitions/DecisionNode";
+                    readonly description: "Decision node for the not applicable path";
+                };
+            };
+            readonly required: readonly ["nodeText", "semanticMeaning"];
+        };
+    };
+};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { DSDecisionGraph, DSDecisionGraphWithSchema } from './DSDecisionGraph.js';
+export { type DSDecisionGraphT } from './react-desc-prop-types.js';
+export { DECISION_GRAPH_SLOTS, DECISION_GRAPH_DATA_TESTID } from './constants/index.js';

package/dist/types/parts/mermaid/MermaidDecisionChart.d.ts

@@ -0,0 +1,8 @@
+import type { DSDecisionGraphT } from '../../react-desc-prop-types.js';
+type MermaidProps = {
+    chartJson: DSDecisionGraphT.Props['chartJson'];
+    uid: string;
+    direction: DSDecisionGraphT.Directions;
+};
+export declare const MermaidDecisionChart: (props: MermaidProps) => import("react/jsx-runtime.js").JSX.Element;
+export {};

package/dist/types/parts/mermaid/decisionTreeToMermaidMD.d.ts

@@ -0,0 +1,8 @@
+import type { DSDecisionGraphT } from '../../react-desc-prop-types.js';
+/**
+ * Flattens a decision tree into a map of flat decision nodes.
+ * @param {DSDecisionGraphT.RootNode} rootNode - The root node of the decision tree to flatten.
+ * @param {DSDecisionGraphT.Directions} direction - direction of the flowchart, default is LR (left to right)
+ * @returns {string} A map of flat decision nodes, where each node is identified by its node ID.
+ */
+export declare const decisionTreeToMermaidMD: (rootNode: DSDecisionGraphT.RootNode, direction?: DSDecisionGraphT.Directions) => string;

package/dist/types/react-desc-prop-types.d.ts

@@ -0,0 +1,54 @@
+import type { GlobalAttributesT, XstyledProps, DSPropTypesSchema } from '@elliemae/ds-props-helpers';
+import type { WeakValidationMap } from 'react';
+export declare namespace DSDecisionGraphT {
+    type Directions = 'LR' | 'TD';
+    type SemanticMeaning = 'question' | 'conclusion';
+    type NodePath = `${string}${'t' | 'f' | 'o' | 's'}`;
+    type ConclusionMarkdown = `${string | NodePath}(${string})`;
+    type QuestionMarkdown = `${string | NodePath}{{${string}}}`;
+    type NodeMarkdown = ConclusionMarkdown | QuestionMarkdown;
+    type TrueLinkMarkdown = `-->|true|`;
+    type FalseLinkMarkdown = `-->|false|`;
+    type NALinkMarkdown = `-->|N/A|`;
+    type LinkMarkdown = TrueLinkMarkdown | FalseLinkMarkdown | NALinkMarkdown | '';
+    /**
+     * Node polymorphism for the "meaning" the node has in the decision tree.
+     *   this influence the node shape in the decision chart.
+     */
+    interface BaseNode {
+        nodeText: string;
+        truePath?: DecisionNode;
+        falsePath?: DecisionNode;
+        notApplicablePath?: DecisionNode;
+        repeatedId?: string;
+    }
+    interface QuestionNode extends BaseNode {
+        semanticMeaning: 'question';
+    }
+    interface ConclusionNode extends BaseNode {
+        semanticMeaning: 'conclusion';
+    }
+    type DecisionNode = QuestionNode | ConclusionNode;
+    /**
+     * yes, polymorphism in typescript is this verbose and this hard to handle correctly.
+     */
+    type RootNode = {
+        chartTitle: string;
+        subtree: DecisionNode;
+    };
+    interface RequiredProps {
+        chartJson: RootNode;
+    }
+    interface DefaultProps {
+        direction: Directions;
+    }
+    interface OptionalProps {
+    }
+    interface Props extends Partial<DefaultProps>, OptionalProps, Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>, XstyledProps, RequiredProps {
+    }
+    interface InternalProps extends DefaultProps, OptionalProps, Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof RequiredProps | keyof XstyledProps>, XstyledProps, RequiredProps {
+    }
+}
+export declare const defaultProps: DSDecisionGraphT.DefaultProps;
+export declare const DSDecisionGraphPropTypes: DSPropTypesSchema<DSDecisionGraphT.Props>;
+export declare const DSDecisionGraphPropTypesSchema: WeakValidationMap<DSDecisionGraphT.Props>;

package/dist/types/tests/DSDecisionGraph.test.d.ts

@@ -0,0 +1 @@
+export {};