door_models 0.1.0

package/dist/context/DoorContext.js

@@ -0,0 +1,631 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConfigurator = exports.ConfiguratorProvider = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["doorDepth"];
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // --- Type Definitions to Match JSON Structure ---
+// --- Main Context Type ---
+const ConfiguratorContext = /*#__PURE__*/(0, _react.createContext)(undefined);
+const ConfiguratorProvider = _ref => {
+  let {
+    children
+  } = _ref;
+  const [isPlaneVisible, setIsPlaneVisible] = (0, _react.useState)(false);
+  const [isFrameVisible, setIsFrameVisible] = (0, _react.useState)(true);
+  const [cpid, setCpid] = (0, _react.useState)("");
+  const [totalHeight, setTotalHeight] = (0, _react.useState)(2700);
+  const [totalWidth, setTotalWidth] = (0, _react.useState)(974);
+  const [glassVisible, setGlassVisible] = (0, _react.useState)(false);
+  const [glassDepth, setGlassDepth] = (0, _react.useState)(8);
+  const [door, setDoor] = (0, _react.useState)({
+    doorMaterial: "door_material",
+    doorWidth: 0,
+    doorHeight: 0,
+    theDoorDepth: 40,
+    doorPivot: "left",
+    doorOpening: "out"
+  });
+  const [doorFrame, setDoorFrame] = (0, _react.useState)({
+    frameMaterial: "doorFrame_material",
+    doorStopMaterial: "doorStop_material",
+    gasketMaterial: "gasket_material",
+    hingeMaterial: "hinge_material",
+    glassMaterial: "glass_material",
+    frameDepth: 103,
+    topThk: "20mm",
+    sidesThk: "20mm",
+    doorStopOffset: "30mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 20,
+    secondDoorStopDepth: 30,
+    secondDoorStopOffset: 13
+  });
+  const [interiorFanlight, setInteriorFanlight] = (0, _react.useState)({
+    visible: false,
+    height: 300,
+    material: "interiorFanlight_material"
+  });
+  const [exteriorFanlight, setExteriorFanlight] = (0, _react.useState)({
+    visible: false,
+    height: 300,
+    depth: 60,
+    material: "exteriorFanlight_material"
+  });
+  const [occulus, setOcculus] = (0, _react.useState)({
+    visible: false,
+    infillVisible: true,
+    x1: 120,
+    x2: 120,
+    y1: 600,
+    y2: 220,
+    material: "infill_material",
+    depth: 20
+  });
+  const [frontCoverPanel, setFrontCoverPanel] = (0, _react.useState)({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "front_cover_material"
+  });
+  const [backCoverPanel, setBackCoverPanel] = (0, _react.useState)({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "back_cover_material"
+  });
+  const [glass, setGlass] = (0, _react.useState)({
+    visible: false,
+    material: "infill_material",
+    depth: 20
+  });
+  const [frameType, setFrameType] = (0, _react.useState)("AF20_40");
+  const [bodyType, setBodyType] = (0, _react.useState)("40");
+  const [exteriorFanlightType, setExteriorFanlightType] = (0, _react.useState)("WPFL");
+  const [testDoorMaterial, setTestDoorMaterial] = (0, _react.useState)("brown");
+  const [testFrameMaterial, setTestFrameMaterial] = (0, _react.useState)("black");
+  const [testGasketMaterial, setTestGasketMaterial] = (0, _react.useState)("darkgrey");
+  const [testInteriorFanlightMaterial, setTestInteriorFanlightMaterial] = (0, _react.useState)("grey");
+  const [testExteriorFanlightMaterial, setTestExteriorFanlightMaterial] = (0, _react.useState)("metal");
+  const [testOcculusInfillMaterial, setTestOcculusInfillMaterial] = (0, _react.useState)("glass");
+  const [testGlassInfillMaterial, setTestGlassInfillMaterial] = (0, _react.useState)("glass");
+  const [testDoorStopMaterial, setTestDoorStopMaterial] = (0, _react.useState)("black");
+  const [testHingeMaterial, setTestHingeMaterial] = (0, _react.useState)("metal");
+  const [testFrontCoverPanelMaterial, setTestFrontCoverPanelMaterial] = (0, _react.useState)("aluminum");
+  const [testBackCoverPanelMaterial, setTestBackCoverPanelMaterial] = (0, _react.useState)("aluminum");
+
+  //
+  const [parseMessage, setParseMessage] = (0, _react.useState)({
+    type: "",
+    text: ""
+  });
+  const handleParseCpid = (0, _react.useCallback)(cpidToParse => {
+    const showMessage = function (text) {
+      let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "error";
+      setParseMessage({
+        text,
+        type
+      });
+      setTimeout(() => setParseMessage({
+        text: "",
+        type: ""
+      }), 4000);
+    };
+    if (!cpidToParse || !cpidToParse.trim().startsWith("P_")) {
+      showMessage("Invalid format: CPID must start with 'P_'.");
+      return;
+    }
+    const parts = cpidToParse.trim().split("_");
+    if (parts.length < 4) {
+      showMessage("Invalid format: Not enough parts in CPID.");
+      return;
+    }
+    const newConfig = {
+      fanlightVisible: false,
+      fanlightType: "WPFL",
+      interiorFanlightVisible: false,
+      occulusVisible: false,
+      frameType: "",
+      bodyType: ""
+    };
+    let currentIndex = 1;
+
+    //  Door Type
+    if (parts[currentIndex] === "SD") {
+      currentIndex++;
+    } else {
+      showMessage("Unsupported Door Type: Only 'SD' is supported.");
+      return;
+    }
+
+    //Fanlight Type
+    const fanlightPart = parts[currentIndex];
+    const validFanlights = ["WPFL", "ALDGFL", "ALSGFL"];
+    if (fanlightPart === "FH") {
+      newConfig.fanlightVisible = false;
+      currentIndex++;
+    } else if (validFanlights.includes(fanlightPart)) {
+      newConfig.fanlightVisible = true;
+      newConfig.fanlightType = fanlightPart;
+      currentIndex++;
+    } else {
+      showMessage("Invalid Fanlight Type: '".concat(fanlightPart, "'."));
+      return;
+    }
+
+    //  Frame and Body Type
+    const validSimpleFrameTypes = ["AF20", "AF40", "WF", "MXF", "MXCAF", "NOF"];
+    const validBodyTypes = ["40", "50", "FLI", "100", "WDG100", "SG8", "SG10", "SG12"];
+    let framePart = parts[currentIndex];
+    let bodyPartRaw = parts[currentIndex + 1] || "";
+    let frameFound = false;
+    if ("".concat(framePart, "_").concat(bodyPartRaw) === "WDGF_WDG100") {
+      newConfig.frameType = "WDGF_WDG100";
+      newConfig.bodyType = "WDG100";
+      currentIndex += 2;
+      frameFound = true;
+    } else if (validSimpleFrameTypes.includes(framePart)) {
+      let tempBody = bodyPartRaw.replace("OCC", "");
+      if (validBodyTypes.includes(tempBody)) {
+        newConfig.frameType = framePart === "NOF" ? "NOF" : "".concat(framePart, "_").concat(tempBody);
+        newConfig.bodyType = tempBody;
+        if (bodyPartRaw.endsWith("OCC")) {
+          newConfig.occulusVisible = true;
+        }
+        currentIndex += 2;
+        frameFound = true;
+      }
+    }
+    if (!frameFound) {
+      showMessage("Invalid Frame/Body combination starting with '".concat(framePart, "'."));
+      return;
+    }
+    for (let i = currentIndex; i < parts.length; i++) {
+      if (parts[i] === "IFL") {
+        newConfig.interiorFanlightVisible = true;
+      } else if (parts[i] === "OCC") {
+        newConfig.occulusVisible = true;
+      }
+    }
+
+    // Apply final configuration
+    setFrameType(newConfig.frameType);
+    setBodyType(newConfig.bodyType);
+    setExteriorFanlight(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      visible: newConfig.fanlightVisible
+    }));
+    if (newConfig.fanlightVisible) {
+      setExteriorFanlightType(newConfig.fanlightType);
+    }
+    setInteriorFanlight(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      visible: newConfig.interiorFanlightVisible
+    }));
+    setOcculus(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      visible: newConfig.occulusVisible
+    }));
+    showMessage("Configuration Applied!", "success");
+  }, [setBodyType, setExteriorFanlight, setExteriorFanlightType, setFrameType, setInteriorFanlight, setOcculus]);
+
+  // --- BodyType Effect ---
+  (0, _react.useEffect)(() => {
+    let newDoorDepth = 40;
+    let newMaterial = "brown";
+    switch (bodyType) {
+      case "50":
+        newDoorDepth = 50;
+        break;
+      case "SG8":
+        newDoorDepth = 8;
+        newMaterial = "glass";
+        break;
+      case "SG10":
+        newDoorDepth = 10;
+        newMaterial = "glass";
+        break;
+      case "SG12":
+        newDoorDepth = 12;
+        newMaterial = "glass";
+        break;
+    }
+    setDoor(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      theDoorDepth: newDoorDepth
+    }));
+    setTestDoorMaterial(newMaterial);
+  }, [bodyType]);
+
+  // --- FrameType Effect ---
+  (0, _react.useEffect)(() => {
+    setIsFrameVisible(frameType !== "NOF");
+    setGlassVisible(false);
+    let newSettings = {};
+    let lookupKey = frameType;
+    if (frameType.startsWith("AF20_SG")) {
+      lookupKey = "AF20_40";
+    } else if (frameType.startsWith("AF40_SG")) {
+      lookupKey = "AF40_40";
+    }
+    switch (lookupKey) {
+      case "NOF":
+        newSettings = {
+          topThk: "0mm",
+          sidesThk: "0mm",
+          frameDepth: 0
+        };
+        break;
+      case "AF20_40":
+        newSettings = {
+          frameDepth: 103,
+          topThk: "20mm",
+          sidesThk: "20mm",
+          doorStopOffset: "42mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        if (frameType === "AF20_40") {
+          newSettings.doorDepth = 40;
+        }
+        break;
+      case "AF20_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "20mm",
+          sidesThk: "20mm",
+          doorStopOffset: "30mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "AF40_40":
+        newSettings = {
+          frameDepth: 103,
+          topThk: "40mm",
+          sidesThk: "40mm",
+          doorStopOffset: "42mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        if (frameType === "AF40_40") {
+          newSettings.doorDepth = 40;
+        }
+        break;
+      case "AF40_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "40mm",
+          sidesThk: "40mm",
+          doorStopOffset: "30mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_40":
+        newSettings = {
+          doorDepth: 39.6,
+          frameDepth: 103,
+          topThk: "31.6mm",
+          sidesThk: "31.6mm",
+          doorStopOffset: "0mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 58.4,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_50":
+        newSettings = {
+          doorDepth: 51.6,
+          frameDepth: 103,
+          topThk: "31.6mm",
+          sidesThk: "31.6mm",
+          doorStopOffset: "0mm",
+          doorStopWidth: 16,
+          doorStopDepth: 46.4,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_100":
+        newSettings = {
+          doorDepth: 102,
+          frameDepth: 102,
+          topThk: "52mm",
+          sidesThk: "52mm",
+          doorStopOffset: "17.6mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 44.8,
+          notchWidth: "16mm",
+          notchDepth: "66.5mm",
+          notchposition: 0.02,
+          gasketDepth: 5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 29,
+          secondDoorStopDepth: 17.6,
+          secondDoorStopOffset: 0
+        };
+        break;
+      case "WF_FLI":
+        newSettings = {
+          doorDepth: 51,
+          frameDepth: 102,
+          topThk: "52mm",
+          sidesThk: "52mm",
+          doorStopOffset: "17.4mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 34,
+          notchWidth: "14mm",
+          notchDepth: "66mm",
+          notchposition: 0.02,
+          gasketDepth: 5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 29,
+          secondDoorStopDepth: 17.6,
+          secondDoorStopOffset: 0
+        };
+        break;
+      case "WDGF_WDG100":
+        newSettings = {
+          doorDepth: 86,
+          frameDepth: 86,
+          topThk: "50mm",
+          sidesThk: "50mm",
+          doorStopOffset: "34mm",
+          doorStopWidth: 13,
+          doorStopDepth: 30,
+          notchWidth: "14mm",
+          notchDepth: "66mm",
+          notchposition: 0.02,
+          gasketDepth: 4.5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 23,
+          secondDoorStopDepth: 30,
+          secondDoorStopOffset: 13
+        };
+        setGlassVisible(true);
+        break;
+      case "MXF_40":
+        newSettings = {
+          doorDepth: 38,
+          frameDepth: 103,
+          topThk: "18mm",
+          sidesThk: "18mm",
+          doorStopOffset: "45mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXF_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "18.2mm",
+          sidesThk: "18.2mm",
+          doorStopOffset: "33mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXCAF_40":
+        newSettings = {
+          doorDepth: 38,
+          frameDepth: 103,
+          topThk: "18mm",
+          sidesThk: "18mm",
+          doorStopOffset: "45mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXCAF_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "18.2mm",
+          sidesThk: "18.2mm",
+          doorStopOffset: "33mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      default:
+        break;
+    }
+    const isMxCaf = frameType.startsWith("MXCAF");
+    setFrontCoverPanel(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    setBackCoverPanel(prev => _objectSpread(_objectSpread({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    const {
+        doorDepth
+      } = newSettings,
+      newFrameSettings = _objectWithoutProperties(newSettings, _excluded);
+    setDoorFrame(prev => _objectSpread(_objectSpread({}, prev), newFrameSettings));
+    if (doorDepth !== undefined) {
+      setDoor(prev => _objectSpread(_objectSpread({}, prev), {}, {
+        theDoorDepth: doorDepth
+      }));
+    }
+  }, [frameType]);
+
+  // ---  Exterior Fanlight Logic ---
+  (0, _react.useEffect)(() => {
+    if (!exteriorFanlight.visible) return;
+    switch (exteriorFanlightType) {
+      case "WPFL":
+        setExteriorFanlight(prev => _objectSpread(_objectSpread({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        setTestExteriorFanlightMaterial("metal");
+        break;
+      case "ALDGL":
+        setExteriorFanlight(prev => _objectSpread(_objectSpread({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        setTestExteriorFanlightMaterial("glass");
+        break;
+      case "ALSGL":
+        setExteriorFanlight(prev => _objectSpread(_objectSpread({}, prev), {}, {
+          depth: 40
+        }));
+        setTestExteriorFanlightMaterial("glass");
+        break;
+      default:
+        break;
+    }
+  }, [exteriorFanlight.visible, exteriorFanlightType, doorFrame.frameDepth, setTestExteriorFanlightMaterial, setExteriorFanlight]);
+  (0, _react.useEffect)(() => {
+    const topThkValue = parseInt(doorFrame.topThk) || 0;
+    const exteriorFanlightHeight = exteriorFanlight.visible ? exteriorFanlight.height : 0;
+    const newDoorHeight = totalHeight - topThkValue - exteriorFanlightHeight;
+    setDoor(prevDoor => _objectSpread(_objectSpread({}, prevDoor), {}, {
+      doorHeight: newDoorHeight > 0 ? newDoorHeight : 0
+    }));
+  }, [totalHeight, doorFrame.topThk, exteriorFanlight.visible, exteriorFanlight.height]);
+  (0, _react.useEffect)(() => {
+    const sidesThkValue = parseInt(doorFrame.sidesThk) || 0;
+    const newDoorWidth = totalWidth - sidesThkValue * 2;
+    setDoor(prevDoor => _objectSpread(_objectSpread({}, prevDoor), {}, {
+      doorWidth: newDoorWidth > 0 ? newDoorWidth : 0
+    }));
+  }, [totalWidth, doorFrame.sidesThk]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(ConfiguratorContext.Provider, {
+    value: {
+      isPlaneVisible,
+      setIsPlaneVisible,
+      isFrameVisible,
+      setIsFrameVisible,
+      cpid,
+      setCpid,
+      door,
+      setDoor,
+      doorFrame,
+      setDoorFrame,
+      interiorFanlight,
+      setInteriorFanlight,
+      exteriorFanlight,
+      setExteriorFanlight,
+      occulus,
+      setOcculus,
+      frontCoverPanel,
+      setFrontCoverPanel,
+      backCoverPanel,
+      setBackCoverPanel,
+      glass,
+      setGlass,
+      frameType,
+      setFrameType,
+      bodyType,
+      setBodyType,
+      totalHeight,
+      setTotalHeight,
+      totalWidth,
+      setTotalWidth,
+      exteriorFanlightType,
+      setExteriorFanlightType,
+      testDoorMaterial,
+      setTestDoorMaterial,
+      testFrameMaterial,
+      setTestFrameMaterial,
+      testGasketMaterial,
+      setTestGasketMaterial,
+      testInteriorFanlightMaterial,
+      setTestInteriorFanlightMaterial,
+      testExteriorFanlightMaterial,
+      setTestExteriorFanlightMaterial,
+      testOcculusInfillMaterial,
+      setTestOcculusInfillMaterial,
+      testGlassInfillMaterial,
+      setTestGlassInfillMaterial,
+      testDoorStopMaterial,
+      setTestDoorStopMaterial,
+      testHingeMaterial,
+      setTestHingeMaterial,
+      testFrontCoverPanelMaterial,
+      setTestFrontCoverPanelMaterial,
+      testBackCoverPanelMaterial,
+      setTestBackCoverPanelMaterial,
+      glassVisible,
+      setGlassVisible,
+      glassDepth,
+      setGlassDepth,
+      handleParseCpid
+    },
+    children: children
+  });
+};
+exports.ConfiguratorProvider = ConfiguratorProvider;
+const useConfigurator = () => {
+  const context = (0, _react.useContext)(ConfiguratorContext);
+  if (!context) {
+    throw new Error("useConfigurator must be used within a ConfiguratorProvider");
+  }
+  return context;
+};
+exports.useConfigurator = useConfigurator;

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ConfiguratorProvider", {
+  enumerable: true,
+  get: function () {
+    return _DoorContext.ConfiguratorProvider;
+  }
+});
+Object.defineProperty(exports, "DoorModels", {
+  enumerable: true,
+  get: function () {
+    return _DoorModels.default;
+  }
+});
+Object.defineProperty(exports, "Interface", {
+  enumerable: true,
+  get: function () {
+    return _Interface.Interface;
+  }
+});
+Object.defineProperty(exports, "useConfigurator", {
+  enumerable: true,
+  get: function () {
+    return _DoorContext.useConfigurator;
+  }
+});
+var _DoorContext = require("./context/DoorContext");
+var _DoorModels = _interopRequireDefault(require("./components/DoorModels"));
+var _Interface = require("./components/Interface");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }