@elliemae/ds-legacy-indeterminate-progress-indicator 1.0.0-rc.1

package/dist/cjs/DSIndeterminateProgressIndicator.js

@@ -0,0 +1,107 @@
+"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 DSIndeterminateProgressIndicator_exports = {};
+__export(DSIndeterminateProgressIndicator_exports, {
+  DSIndeterminateProgressIndicator: () => DSIndeterminateProgressIndicator,
+  IndeterminateProgressIndicatorWithSchema: () => IndeterminateProgressIndicatorWithSchema,
+  default: () => DSIndeterminateProgressIndicator_default
+});
+module.exports = __toCommonJS(DSIndeterminateProgressIndicator_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_useIndeterminateProgressIndicator = require("./config/useIndeterminateProgressIndicator.js");
+var import_constants = require("./constants/index.js");
+var import_ds_legacy_truncated_tooltip_text = require("@elliemae/ds-legacy-truncated-tooltip-text");
+var import_styled = require("./styled.js");
+const DSIndeterminateProgressIndicator = (props) => {
+  const { propsWithDefault, label } = (0, import_useIndeterminateProgressIndicator.useIndeterminateProgressIndicator)(props);
+  const {
+    containerProps,
+    complete,
+    failed,
+    processing,
+    processingComplete,
+    processingFail,
+    animated,
+    percent,
+    lineOnly
+  } = propsWithDefault;
+  const globalAttributes = (0, import_ds_legacy_props_helpers.useGetGlobalAttributes)(propsWithDefault);
+  const xstyledAttributes = (0, import_ds_legacy_props_helpers.useGetXstyledProps)(propsWithDefault);
+  const getOwnerProps = (0, import_react.useCallback)(() => propsWithDefault, [propsWithDefault]);
+  const getOwnerPropsArguments = (0, import_react.useCallback)(() => ({}), []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    import_styled.Container,
+    {
+      "aria-busy": processing,
+      "aria-label": label,
+      "aria-live": "polite",
+      role: "alert",
+      lineOnly,
+      getOwnerProps,
+      getOwnerPropsArguments,
+      ...globalAttributes,
+      ...xstyledAttributes,
+      ...containerProps,
+      children: [
+        !lineOnly ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_truncated_tooltip_text.TooltipTextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          import_styled.StyledTruncatedTooltipText,
+          {
+            value: label,
+            getOwnerProps,
+            getOwnerPropsArguments
+          }
+        ) }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_styled.Bar, { getOwnerProps, getOwnerPropsArguments, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          import_styled.BarIndicator,
+          {
+            complete,
+            failed,
+            processing,
+            animated,
+            processingComplete,
+            processingFail,
+            percent,
+            getOwnerProps,
+            getOwnerPropsArguments
+          }
+        ) })
+      ]
+    }
+  );
+};
+DSIndeterminateProgressIndicator.propTypes = import_react_desc_prop_types.DSIndeterminateProgressIndicatorPropTypes;
+DSIndeterminateProgressIndicator.displayName = import_constants.DSIndeterminateProgressIndicatorName;
+const IndeterminateProgressIndicatorWithSchema = (0, import_ds_legacy_props_helpers.describe)(DSIndeterminateProgressIndicator);
+IndeterminateProgressIndicatorWithSchema.propTypes = import_react_desc_prop_types.DSIndeterminateProgressIndicatorPropTypes;
+var DSIndeterminateProgressIndicator_default = DSIndeterminateProgressIndicator;
+//# sourceMappingURL=DSIndeterminateProgressIndicator.js.map

package/dist/cjs/DSIndeterminateProgressIndicator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSIndeterminateProgressIndicator.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { useCallback } from 'react';\nimport { describe, useGetGlobalAttributes, useGetXstyledProps } from '@elliemae/ds-legacy-props-helpers';\nimport {\n  DSIndeterminateProgressIndicatorPropTypes,\n  type DSIndeterminateProgressIndicatorT,\n} from './react-desc-prop-types.js';\nimport { useIndeterminateProgressIndicator } from './config/useIndeterminateProgressIndicator.js';\nimport { DSIndeterminateProgressIndicatorName } from './constants/index.js';\nimport { TooltipTextProvider } from '@elliemae/ds-legacy-truncated-tooltip-text';\nimport { Bar, BarIndicator, Container, StyledTruncatedTooltipText } from './styled.js';\n\nconst DSIndeterminateProgressIndicator: React.ComponentType<DSIndeterminateProgressIndicatorT.Props> = (props) => {\n  const { propsWithDefault, label } = useIndeterminateProgressIndicator(props);\n  const {\n    containerProps,\n    complete,\n    failed,\n    processing,\n    processingComplete,\n    processingFail,\n    animated,\n    percent,\n    lineOnly,\n  } = propsWithDefault;\n\n  const globalAttributes = useGetGlobalAttributes(propsWithDefault);\n  const xstyledAttributes = useGetXstyledProps(propsWithDefault);\n  const getOwnerProps = useCallback(() => propsWithDefault, [propsWithDefault]);\n  const getOwnerPropsArguments = useCallback(() => ({}), []);\n\n  return (\n    <Container\n      aria-busy={processing}\n      aria-label={label}\n      aria-live=\"polite\"\n      role=\"alert\"\n      lineOnly={lineOnly}\n      getOwnerProps={getOwnerProps}\n      getOwnerPropsArguments={getOwnerPropsArguments}\n      {...globalAttributes}\n      {...xstyledAttributes}\n      {...containerProps}\n    >\n      {!lineOnly ? (\n        <TooltipTextProvider>\n          <StyledTruncatedTooltipText\n            value={label}\n            getOwnerProps={getOwnerProps}\n            getOwnerPropsArguments={getOwnerPropsArguments}\n          />\n        </TooltipTextProvider>\n      ) : null}\n      <Bar getOwnerProps={getOwnerProps} getOwnerPropsArguments={getOwnerPropsArguments}>\n        <BarIndicator\n          complete={complete}\n          failed={failed}\n          processing={processing}\n          animated={animated}\n          processingComplete={processingComplete}\n          processingFail={processingFail}\n          percent={percent}\n          getOwnerProps={getOwnerProps}\n          getOwnerPropsArguments={getOwnerPropsArguments}\n        />\n      </Bar>\n    </Container>\n  );\n};\n\nDSIndeterminateProgressIndicator.propTypes = DSIndeterminateProgressIndicatorPropTypes;\nDSIndeterminateProgressIndicator.displayName = DSIndeterminateProgressIndicatorName;\nconst IndeterminateProgressIndicatorWithSchema = describe(DSIndeterminateProgressIndicator);\nIndeterminateProgressIndicatorWithSchema.propTypes = DSIndeterminateProgressIndicatorPropTypes;\n\nexport { DSIndeterminateProgressIndicator, IndeterminateProgressIndicatorWithSchema };\nexport default DSIndeterminateProgressIndicator;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;AD+BnB;AA/BJ,mBAAmC;AACnC,qCAAqE;AACrE,mCAGO;AACP,+CAAkD;AAClD,uBAAqD;AACrD,8CAAoC;AACpC,oBAAyE;AAEzE,MAAM,mCAAiG,CAAC,UAAU;AAChH,QAAM,EAAE,kBAAkB,MAAM,QAAI,4EAAkC,KAAK;AAC3E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,uBAAmB,uDAAuB,gBAAgB;AAChE,QAAM,wBAAoB,mDAAmB,gBAAgB;AAC7D,QAAM,oBAAgB,0BAAY,MAAM,kBAAkB,CAAC,gBAAgB,CAAC;AAC5E,QAAM,6BAAyB,0BAAY,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzD,SACE;AAAA,IAAC;AAAA;AAAA,MACC,aAAW;AAAA,MACX,cAAY;AAAA,MACZ,aAAU;AAAA,MACV,MAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACC,GAAG;AAAA,MACH,GAAG;AAAA,MACH,GAAG;AAAA,MAEH;AAAA,SAAC,WACA,4CAAC,+DACC;AAAA,UAAC;AAAA;AAAA,YACC,OAAO;AAAA,YACP;AAAA,YACA;AAAA;AAAA,QACF,GACF,IACE;AAAA,QACJ,4CAAC,qBAAI,eAA8B,wBACjC;AAAA,UAAC;AAAA;AAAA,YACC;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA;AAAA,QACF,GACF;AAAA;AAAA;AAAA,EACF;AAEJ;AAEA,iCAAiC,YAAY;AAC7C,iCAAiC,cAAc;AAC/C,MAAM,+CAA2C,yCAAS,gCAAgC;AAC1F,yCAAyC,YAAY;AAGrD,IAAO,2CAAQ;",
+  "names": []
+}

package/dist/cjs/config/useIndeterminateProgressIndicator.js

@@ -0,0 +1,78 @@
+"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 useIndeterminateProgressIndicator_exports = {};
+__export(useIndeterminateProgressIndicator_exports, {
+  useIndeterminateProgressIndicator: () => useIndeterminateProgressIndicator
+});
+module.exports = __toCommonJS(useIndeterminateProgressIndicator_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_react_desc_prop_types = require("../react-desc-prop-types.js");
+var import_useValidateProps = require("./useValidateProps.js");
+const useIndeterminateProgressIndicator = (propsFromUser) => {
+  const propsWithDefault = (0, import_ds_legacy_props_helpers.useMemoMergePropsWithDefault)(
+    propsFromUser,
+    import_react_desc_prop_types.defaultProps
+  );
+  (0, import_useValidateProps.useValidateProps)(propsWithDefault, import_react_desc_prop_types.DSIndeterminateProgressIndicatorPropTypes);
+  const {
+    title,
+    complete,
+    failed,
+    processing,
+    processingComplete,
+    processingCompleteTitle,
+    processingFail,
+    processingFailTitle
+  } = propsWithDefault;
+  const label = (0, import_react.useMemo)(() => {
+    if ((processingComplete || processingFail || processing) && (complete || failed)) {
+      return complete ? processingCompleteTitle : processingFailTitle;
+    }
+    return title;
+  }, [
+    processingComplete,
+    processingFail,
+    processing,
+    complete,
+    failed,
+    title,
+    processingCompleteTitle,
+    processingFailTitle
+  ]);
+  return import_react.default.useMemo(
+    () => ({
+      propsWithDefault,
+      label
+    }),
+    [propsWithDefault, label]
+  );
+};
+//# sourceMappingURL=useIndeterminateProgressIndicator.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useIndeterminateProgressIndicator.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { useMemo } from 'react';\nimport { useMemoMergePropsWithDefault } from '@elliemae/ds-legacy-props-helpers';\nimport {\n  type DSIndeterminateProgressIndicatorT,\n  DSIndeterminateProgressIndicatorPropTypes,\n  defaultProps,\n} from '../react-desc-prop-types.js';\nimport { useValidateProps } from './useValidateProps.js';\n\nexport interface IndeterminateProgressIndicatorCTX {\n  propsWithDefault: DSIndeterminateProgressIndicatorT.InternalProps;\n}\n\nexport const useIndeterminateProgressIndicator = (propsFromUser: DSIndeterminateProgressIndicatorT.Props) => {\n  // =============================================================================\n  // MERGE WITH DEFAULT AND VALIDATE PROPS\n  // =============================================================================\n  const propsWithDefault = useMemoMergePropsWithDefault<DSIndeterminateProgressIndicatorT.InternalProps>(\n    propsFromUser,\n    defaultProps,\n  );\n  useValidateProps(propsWithDefault, DSIndeterminateProgressIndicatorPropTypes);\n  // =============================================================================\n  // AD HOC PER COMPONENT LOGIC\n  // =============================================================================\n  const {\n    title,\n    complete,\n    failed,\n    processing,\n    processingComplete,\n    processingCompleteTitle,\n    processingFail,\n    processingFailTitle,\n  } = propsWithDefault;\n\n  const label = useMemo(() => {\n    if ((processingComplete || processingFail || processing) && (complete || failed)) {\n      return complete ? processingCompleteTitle : processingFailTitle;\n    }\n    return title;\n  }, [\n    processingComplete,\n    processingFail,\n    processing,\n    complete,\n    failed,\n    title,\n    processingCompleteTitle,\n    processingFailTitle,\n  ]);\n\n  return React.useMemo(\n    () => ({\n      propsWithDefault,\n      label,\n    }),\n    [propsWithDefault, label],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA+B;AAC/B,qCAA6C;AAC7C,mCAIO;AACP,8BAAiC;AAM1B,MAAM,oCAAoC,CAAC,kBAA2D;AAI3G,QAAM,uBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,gDAAiB,kBAAkB,sEAAyC;AAI5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,YAAQ,sBAAQ,MAAM;AAC1B,SAAK,sBAAsB,kBAAkB,gBAAgB,YAAY,SAAS;AAChF,aAAO,WAAW,0BAA0B;AAAA,IAC9C;AACA,WAAO;AAAA,EACT,GAAG;AAAA,IACD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO,aAAAA,QAAM;AAAA,IACX,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA,CAAC,kBAAkB,KAAK;AAAA,EAC1B;AACF;",
+  "names": ["React"]
+}

package/dist/cjs/config/useValidateProps.js

@@ -0,0 +1,40 @@
+"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_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_constants = require("../constants/index.js");
+const useValidateProps = (props, propTypes) => {
+  (0, import_ds_legacy_props_helpers.useValidateTypescriptPropTypes)(props, propTypes, import_constants.DSIndeterminateProgressIndicatorName);
+};
+//# 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 { useValidateTypescriptPropTypes } from '@elliemae/ds-legacy-props-helpers';\nimport type { WeakValidationMap } from 'react';\nimport { type DSIndeterminateProgressIndicatorT } from '../react-desc-prop-types.js';\nimport { DSIndeterminateProgressIndicatorName } from '../constants/index.js';\n\nexport const useValidateProps = (\n  props: DSIndeterminateProgressIndicatorT.InternalProps,\n  propTypes: WeakValidationMap<unknown>,\n): void => {\n  // we validate the \"required if\" via 'isRequiredIf from our custom PropTypes\n  useValidateTypescriptPropTypes(props, propTypes, DSIndeterminateProgressIndicatorName);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,qCAA+C;AAG/C,uBAAqD;AAE9C,MAAM,mBAAmB,CAC9B,OACA,cACS;AAET,qEAA+B,OAAO,WAAW,qDAAoC;AACvF;",
+  "names": []
+}

package/dist/cjs/constants/index.js

@@ -0,0 +1,49 @@
+"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, {
+  DSIndeterminateProgressIndicatorDataTestIds: () => DSIndeterminateProgressIndicatorDataTestIds,
+  DSIndeterminateProgressIndicatorName: () => DSIndeterminateProgressIndicatorName,
+  DSIndeterminateProgressIndicatorSlots: () => DSIndeterminateProgressIndicatorSlots
+});
+module.exports = __toCommonJS(constants_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_system = require("@elliemae/ds-legacy-system");
+const DSIndeterminateProgressIndicatorName = "DSIndeterminateProgressIndicator";
+const DSIndeterminateProgressIndicatorSlots = {
+  ROOT: "root",
+  LABEL: "label",
+  BAR: "bar",
+  BAR_INDICATOR: "bar_indicator"
+};
+const DSIndeterminateProgressIndicatorDataTestIds = (0, import_ds_legacy_system.slotObjectToDataTestIds)(
+  DSIndeterminateProgressIndicatorName,
+  DSIndeterminateProgressIndicatorSlots
+);
+//# 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-legacy-system';\n\nexport const DSIndeterminateProgressIndicatorName = 'DSIndeterminateProgressIndicator';\n\nexport const DSIndeterminateProgressIndicatorSlots = {\n  ROOT: 'root',\n  LABEL: 'label',\n  BAR: 'bar',\n  BAR_INDICATOR: 'bar_indicator',\n};\n\nexport const DSIndeterminateProgressIndicatorDataTestIds = slotObjectToDataTestIds(\n  DSIndeterminateProgressIndicatorName,\n  DSIndeterminateProgressIndicatorSlots,\n);\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAAwC;AAEjC,MAAM,uCAAuC;AAE7C,MAAM,wCAAwC;AAAA,EACnD,MAAM;AAAA,EACN,OAAO;AAAA,EACP,KAAK;AAAA,EACL,eAAe;AACjB;AAEO,MAAM,kDAA8C;AAAA,EACzD;AAAA,EACA;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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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, {
+  DSIndeterminateProgressIndicatorName: () => import_constants.DSIndeterminateProgressIndicatorName,
+  DSIndeterminateProgressIndicatorSlots: () => import_constants.DSIndeterminateProgressIndicatorSlots,
+  default: () => import_DSIndeterminateProgressIndicator.default
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+__reExport(src_exports, require("./DSIndeterminateProgressIndicator.js"), module.exports);
+var import_DSIndeterminateProgressIndicator = __toESM(require("./DSIndeterminateProgressIndicator.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.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './DSIndeterminateProgressIndicator.js';\nexport { default } from './DSIndeterminateProgressIndicator.js';\nexport { DSIndeterminateProgressIndicatorName, DSIndeterminateProgressIndicatorSlots } from './constants/index.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,wBAAc,kDAAd;AACA,8CAAwB;AACxB,uBAA4F;",
+  "names": []
+}

package/dist/cjs/package.json

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

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

@@ -0,0 +1,67 @@
+"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, {
+  DSIndeterminateProgressIndicatorPropTypes: () => DSIndeterminateProgressIndicatorPropTypes,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+const defaultProps = {
+  containerProps: {},
+  title: "",
+  complete: false,
+  failed: false,
+  processing: false,
+  processingComplete: false,
+  processingCompleteTitle: "Complete",
+  processingFail: false,
+  processingFailTitle: "Fail",
+  animated: true,
+  percent: 50,
+  lineOnly: false
+};
+const DSIndeterminateProgressIndicatorPropTypes = {
+  ...import_ds_legacy_props_helpers.globalAttributesPropTypes,
+  ...import_ds_legacy_props_helpers.xstyledPropTypes,
+  containerProps: import_ds_legacy_props_helpers.PropTypes.object.description("Set of Properties attached to the main container"),
+  title: import_ds_legacy_props_helpers.PropTypes.string.description("component s label"),
+  complete: import_ds_legacy_props_helpers.PropTypes.bool.description("Sets the process state to completed").defaultValue(false),
+  failed: import_ds_legacy_props_helpers.PropTypes.bool.description("Sets the process state to failed").defaultValue(false),
+  processing: import_ds_legacy_props_helpers.PropTypes.bool.description("Sets the process state to processing").defaultValue(false),
+  processingComplete: import_ds_legacy_props_helpers.PropTypes.bool.description("Sets the process state to processing and then completed").defaultValue(false),
+  processingCompleteTitle: import_ds_legacy_props_helpers.PropTypes.string.description("label to display when the process is completed"),
+  processingFail: import_ds_legacy_props_helpers.PropTypes.bool.description("Sets the process state to processing and then failed").defaultValue(false),
+  processingFailTitle: import_ds_legacy_props_helpers.PropTypes.string.description("label to display when the process has failed"),
+  animated: import_ds_legacy_props_helpers.PropTypes.bool.description("animate or not").defaultValue(true),
+  percent: import_ds_legacy_props_helpers.PropTypes.number.description("completion percentage").defaultValue(50),
+  lineOnly: import_ds_legacy_props_helpers.PropTypes.bool.description("hide the label from rendering")
+};
+//# sourceMappingURL=react-desc-prop-types.js.map

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": ["import type { GlobalAttributesT, XstyledProps } from '@elliemae/ds-legacy-props-helpers';\nimport { PropTypes, globalAttributesPropTypes, xstyledPropTypes } from '@elliemae/ds-legacy-props-helpers';\n\nexport declare namespace DSIndeterminateProgressIndicatorT {\n  export interface RequiredProps {}\n\n  export interface DefaultProps {\n    containerProps: object;\n    title: string;\n    complete: boolean;\n    failed: boolean;\n    processing: boolean;\n    processingComplete: boolean;\n    processingCompleteTitle: string;\n    processingFail: boolean;\n    processingFailTitle: string;\n    animated: boolean;\n    percent: number;\n    lineOnly: boolean;\n  }\n\n  export interface OptionalProps {}\n\n  export interface Props\n    extends Partial<DefaultProps>,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLDivElement>, keyof DefaultProps>,\n      XstyledProps,\n      RequiredProps {}\n\n  export interface InternalProps\n    extends DefaultProps,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLDivElement>, keyof DefaultProps>,\n      XstyledProps,\n      RequiredProps {}\n}\n\nexport const defaultProps: DSIndeterminateProgressIndicatorT.DefaultProps = {\n  containerProps: {},\n  title: '',\n  complete: false,\n  failed: false,\n  processing: false,\n  processingComplete: false,\n  processingCompleteTitle: 'Complete',\n  processingFail: false,\n  processingFailTitle: 'Fail',\n  animated: true,\n  percent: 50,\n  lineOnly: false,\n};\n\nexport const DSIndeterminateProgressIndicatorPropTypes = {\n  ...globalAttributesPropTypes,\n  ...xstyledPropTypes,\n  containerProps: PropTypes.object.description('Set of Properties attached to the main container'),\n  title: PropTypes.string.description('component s label'),\n  complete: PropTypes.bool.description('Sets the process state to completed').defaultValue(false),\n  failed: PropTypes.bool.description('Sets the process state to failed').defaultValue(false),\n  processing: PropTypes.bool.description('Sets the process state to processing').defaultValue(false),\n  processingComplete: PropTypes.bool\n    .description('Sets the process state to processing and then completed')\n    .defaultValue(false),\n  processingCompleteTitle: PropTypes.string.description('label to display when the process is completed'),\n  processingFail: PropTypes.bool\n    .description('Sets the process state to processing and then failed')\n    .defaultValue(false),\n  processingFailTitle: PropTypes.string.description('label to display when the process has failed'),\n  animated: PropTypes.bool.description('animate or not').defaultValue(true),\n  percent: PropTypes.number.description('completion percentage').defaultValue(50),\n  lineOnly: PropTypes.bool.description('hide the label from rendering'),\n} as React.WeakValidationMap<unknown>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,qCAAuE;AAqChE,MAAM,eAA+D;AAAA,EAC1E,gBAAgB,CAAC;AAAA,EACjB,OAAO;AAAA,EACP,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,oBAAoB;AAAA,EACpB,yBAAyB;AAAA,EACzB,gBAAgB;AAAA,EAChB,qBAAqB;AAAA,EACrB,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AACZ;AAEO,MAAM,4CAA4C;AAAA,EACvD,GAAG;AAAA,EACH,GAAG;AAAA,EACH,gBAAgB,yCAAU,OAAO,YAAY,kDAAkD;AAAA,EAC/F,OAAO,yCAAU,OAAO,YAAY,mBAAmB;AAAA,EACvD,UAAU,yCAAU,KAAK,YAAY,qCAAqC,EAAE,aAAa,KAAK;AAAA,EAC9F,QAAQ,yCAAU,KAAK,YAAY,kCAAkC,EAAE,aAAa,KAAK;AAAA,EACzF,YAAY,yCAAU,KAAK,YAAY,sCAAsC,EAAE,aAAa,KAAK;AAAA,EACjG,oBAAoB,yCAAU,KAC3B,YAAY,yDAAyD,EACrE,aAAa,KAAK;AAAA,EACrB,yBAAyB,yCAAU,OAAO,YAAY,gDAAgD;AAAA,EACtG,gBAAgB,yCAAU,KACvB,YAAY,sDAAsD,EAClE,aAAa,KAAK;AAAA,EACrB,qBAAqB,yCAAU,OAAO,YAAY,8CAA8C;AAAA,EAChG,UAAU,yCAAU,KAAK,YAAY,gBAAgB,EAAE,aAAa,IAAI;AAAA,EACxE,SAAS,yCAAU,OAAO,YAAY,uBAAuB,EAAE,aAAa,EAAE;AAAA,EAC9E,UAAU,yCAAU,KAAK,YAAY,+BAA+B;AACtE;",
+  "names": []
+}

package/dist/cjs/styled.js

@@ -0,0 +1,182 @@
+"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 styled_exports = {};
+__export(styled_exports, {
+  Bar: () => Bar,
+  BarIndicator: () => BarIndicator,
+  Container: () => Container,
+  StyledTruncatedTooltipText: () => StyledTruncatedTooltipText
+});
+module.exports = __toCommonJS(styled_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_system = require("@elliemae/ds-legacy-system");
+var import_ds_legacy_truncated_tooltip_text = require("@elliemae/ds-legacy-truncated-tooltip-text");
+var import_constants = require("./constants/index.js");
+const IndeterminateAnimation = (color) => import_ds_legacy_system.kfrm`
+  0% {
+    transform: scaleX(0.015);
+    transform-origin: 0% 0%;
+    background-image: linear-gradient(to right, rgba(255,255,255,0.8) 10%, ${color});
+  }
+  25% {
+    transform: scaleX(0.4);
+  }
+  50% {
+    transform: scaleX(0.015);
+    transform-origin: 100% 0%;
+    background-image: linear-gradient(to right, rgba(255,255,255,0.8) 10%, ${color});
+  }
+  50.1% {
+    transform: scaleX(0.015);
+    transform-origin: 100% 0%;
+    background-image: linear-gradient(to left, rgba(255,255,255,0.8) 10%, ${color});
+  }
+  75% {
+    transform: scaleX(0.4);
+  }
+  100% {
+    transform: scaleX(0.015);
+    transform-origin: 0% 0%;
+    background-image: linear-gradient(to left, rgba(255,255,255,0.8) 10%, ${color});
+  }
+`;
+const ProcessingSuccess = import_ds_legacy_system.kfrm`
+  0%, 30% { transform: translateX(-50%); width: 50% }
+  15%     { transform: translateX(150%); width: 50% }
+  0%, 60% { transform: translateX(-50%); width: 50% }
+  45%     { transform: translateX(150%); width: 50% }
+  0%, 90% { transform: translateX(-50%); width: 50% }
+  75%     { transform: translateX(150%); width: 50% }
+  100%    { transform: translateX(0%); }
+`;
+const ProcessingSuccessEnd = (color) => import_ds_legacy_system.kfrm`
+  0%      { transform: translateX(-50%); width: 50% }
+  45%     { transform: translateX(150%); width: 50% }
+  100%    { transform: translateX(0%); background-color: ${color}; }
+`;
+const ProcessingFail = import_ds_legacy_system.kfrm`
+  0%, 30% { transform: translateX(-50%); width: 50% }
+  15%     { transform: translateX(150%); width: 50% }
+  0%, 60% { transform: translateX(-50%); width: 50% }
+  45%     { transform: translateX(150%); width: 50% }
+  0%, 90% { transform: translateX(-50%); width: 50% }
+  75%     { transform: translateX(150%); width: 50%; }
+  100%    { transform: translateX(0%); }
+`;
+const ProcessingFailEnd = import_ds_legacy_system.kfrm`
+  0%      { transform: translateX(-50%); width: 50% }
+  45%     { transform: translateX(150%); width: 50% }
+  100%    { transform: translateX(0%); background-color: #e34256; }
+`;
+const Container = (0, import_ds_legacy_system.styled)("div", {
+  name: import_constants.DSIndeterminateProgressIndicatorName,
+  slot: import_constants.DSIndeterminateProgressIndicatorSlots.ROOT
+})`
+  width: 100%;
+  padding: ${({ theme, lineOnly }) => lineOnly ? 0 : `${theme.space.xxs} ${theme.space.xs}`};
+`;
+const StyledTruncatedTooltipText = (0, import_ds_legacy_system.styled)(import_ds_legacy_truncated_tooltip_text.DSTruncatedTooltipText, {
+  name: import_constants.DSIndeterminateProgressIndicatorName,
+  slot: import_constants.DSIndeterminateProgressIndicatorSlots.LABEL
+})``;
+const Bar = (0, import_ds_legacy_system.styled)("div", {
+  name: import_constants.DSIndeterminateProgressIndicatorName,
+  slot: import_constants.DSIndeterminateProgressIndicatorSlots.BAR
+})`
+  background-color: ${({ theme }) => theme.colors.neutral[100]};
+  overflow: hidden;
+`;
+const BarIndicator = (0, import_ds_legacy_system.styled)("div", {
+  name: import_constants.DSIndeterminateProgressIndicatorName,
+  slot: import_constants.DSIndeterminateProgressIndicatorSlots.BAR_INDICATOR
+})`
+  height: ${({ theme }) => theme.space.xxxs};
+  width: ${({ complete, failed, animated, processing, percent }) => `${!complete && !failed && !animated && processing ? percent : 100}%`};
+  ${({ theme, complete, failed, processing, animated, processingComplete, processingFail }) => {
+  if (!complete && !failed && !processing && !processingComplete && !processingFail)
+    return import_ds_legacy_system.css`
+        background-color: ${theme.colors.neutral[500]};
+      `;
+  else if (complete && processing)
+    return import_ds_legacy_system.css`
+        width: 100%;
+        background-color: ${theme.colors.brand[500]};
+        animation: ${ProcessingSuccessEnd(theme.colors.success[900])} 1s ease-in-out;
+        animation-fill-mode: forwards;
+      `;
+  else if (complete && !processingComplete && !processing)
+    return import_ds_legacy_system.css`
+        background-color: ${theme.colors.success[900]};
+      `;
+  else if (failed && !processingFail && !processing)
+    return import_ds_legacy_system.css`
+        background-color: #e34256;
+      `;
+  else if (processing) {
+    if (animated) {
+      return import_ds_legacy_system.css`
+          width: 100%;
+          animation: ${IndeterminateAnimation(theme.colors.brand[500])} 2s cubic-bezier(0.645, 0.045, 0.355, 1) infinite;
+          background-color: ${theme.colors.brand[500]};
+        `;
+    }
+    return import_ds_legacy_system.css`
+        background-color: ${theme.colors.brand[500]};
+      `;
+  } else if (processingComplete && !complete) {
+    return import_ds_legacy_system.css`
+        width: 50%;
+        animation: ${ProcessingSuccess} 4s infinite;
+        animation-fill-mode: forwards;
+        background-color: ${theme.colors.brand[500]};
+      `;
+  } else if (processingComplete && complete)
+    return import_ds_legacy_system.css`
+        width: 100%;
+        background-color: ${theme.colors.brand[500]};
+        animation: ${ProcessingSuccessEnd(theme.colors.success[900])} 1s ease-in-out;
+        animation-fill-mode: forwards;
+      `;
+  else if (processingFail && !failed)
+    return import_ds_legacy_system.css`
+        width: 50%;
+        animation: ${ProcessingFail} 4s infinite;
+        animation-fill-mode: forwards;
+        background-color: ${theme.colors.brand[500]};
+      `;
+  else if (processingFail && failed)
+    return import_ds_legacy_system.css`
+        width: 100%;
+        background-color: ${theme.colors.brand[500]};
+        animation: ${ProcessingFailEnd} 1s ease-in-out;
+        animation-fill-mode: forwards;
+      `;
+}};
+`;
+//# sourceMappingURL=styled.js.map