@awesome-flow/noise 0.3.0 → 0.5.0

package/dist/nodes/generators/index.js

@@ -1,149 +1,14 @@
 // src/nodes/generators/noise-billow-node.tsx
 import { NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
-import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useCallback, useMemo } from "react";
 import { Billow } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
-import { nodeDataPropertyExcept as nodeDataPropertyExcept2 } from "@awesome-flow/core/abstract";
-
-// src/layout/node-property-variables.tsx
-import { useIncomingNodeData, useUpdateNodeData } from "@awesome-flow/core/hooks";
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { Group, Stack } from "@mantine/core";
-import { getObjectKeys } from "@awesome-flow/core/utils";
-import { nodeDataPropertyExcept } from "@awesome-flow/core/abstract";
-
-// src/layout/node-value-input.tsx
-import { Input, NumberInput, Switch } from "@mantine/core";
-import { Fragment, jsx } from "react/jsx-runtime";
-function NodeValueInput({ value, disabled, step, onChange }) {
-  if (value === void 0 || value === null) {
-    return /* @__PURE__ */ jsx(Fragment, {});
-  }
-  switch (typeof value) {
-    case "boolean": {
-      return /* @__PURE__ */ jsx(
-        Switch,
-        {
-          checked: value,
-          disabled,
-          onChange: (e) => onChange(e.currentTarget.checked)
-        }
-      );
-    }
-    case "number": {
-      return /* @__PURE__ */ jsx(NumberInput, { value, disabled, step, onChange: (e) => onChange(e) });
-    }
-    case "string": {
-      return /* @__PURE__ */ jsx(
-        Input,
-        {
-          value,
-          disabled,
-          onChange: (e) => onChange(e.currentTarget.value)
-        }
-      );
-    }
-    default:
-      throw new Error(`Unknown input node for value of type: ${typeof value} (${value})`);
-  }
-}
-var node_value_input_default = NodeValueInput;
-
-// src/layout/node-property-input.tsx
-import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
-function NodePropertyInput({ property, onChange }) {
-  if (!property) {
-    return /* @__PURE__ */ jsx2(Fragment2, {});
-  }
-  return /* @__PURE__ */ jsx2(
-    node_value_input_default,
-    {
-      value: property.value,
-      disabled: property.disabled,
-      step: property.step,
-      onChange: (value) => onChange(property.name, value)
-    }
-  );
-}
-var node_property_input_default = NodePropertyInput;
-
-// src/layout/node-property-variables.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-function NodePropertyVariables({
-  data,
-  nodeId,
-  onPropertiesChange,
-  except = nodeDataPropertyExcept
-}) {
-  const [properties, setProperties] = useState(() => {
-    const keys = getObjectKeys(data, except);
-    const dataProps = {};
-    for (const key of keys) {
-      dataProps[key] = {
-        name: key,
-        value: data[key]
-      };
-    }
-    return dataProps;
-  });
-  const updateNodeData = useUpdateNodeData();
-  const incoming = useIncomingNodeData(nodeId);
-  const resetAllDisabled = useCallback(() => {
-    const keys = Object.keys(properties);
-    keys.forEach((k) => {
-      properties[k].disabled = false;
-    });
-    setProperties(properties);
-  }, []);
-  const updatePropertyValue = useCallback((name, value, disabled) => {
-    let property = properties[name];
-    if (property) {
-      property.value = value;
-    } else {
-      property = {
-        name,
-        value
-      };
-    }
-    property.disabled = disabled;
-    setProperties({ ...properties, [name]: property });
-    updateNodeData(nodeId, { [name]: value });
-  }, []);
-  useEffect(() => {
-    resetAllDisabled();
-    if (incoming?.length) {
-      for (const connection of incoming) {
-        if (connection.property && properties[connection.property.name] !== void 0) {
-          updatePropertyValue(connection.property.name, connection.property.value, true);
-        }
-      }
-    }
-  }, [incoming]);
-  useEffect(() => {
-    if (onPropertiesChange) {
-      onPropertiesChange(properties);
-    }
-  }, [onPropertiesChange, properties]);
-  const nodes = useMemo(() => {
-    return Object.keys(properties).map((key) => {
-      const property = properties[key];
-      return /* @__PURE__ */ jsxs(Group, { children: [
-        property.name,
-        ":",
-        /* @__PURE__ */ jsx3(node_property_input_default, { property, onChange: updatePropertyValue })
-      ] }, key);
-    });
-  }, [properties, updatePropertyValue]);
-  return /* @__PURE__ */ jsx3(Stack, { children: nodes });
-}
-var node_property_variables_default = NodePropertyVariables;
-
-// src/nodes/generators/noise-billow-node.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { NodePropertyVariables } from "@awesome-flow/core/components";
+import { jsx, jsxs } from "react/jsx-runtime";
 function NoiseBillowNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData();
-  const module = useMemo2(() => new Billow(), []);
-  const onPropertiesChange = useCallback2(
+  const module = useMemo(() => new Billow(), []);
+  const onPropertiesChange = useCallback(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -152,65 +17,57 @@ function NoiseBillowNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs2(NodeContainer, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx4(
-      node_property_variables_default,
-      {
-        data,
-        except: nodeDataPropertyExcept2,
-        nodeId: id,
-        onPropertiesChange
-      }
-    ),
-    /* @__PURE__ */ jsx4(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs(NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx(NodePropertyVariables, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_billow_node_default = NoiseBillowNode;
 
 // src/nodes/generators/noise-checkerboard-node.tsx
 import { NodeContainer as NodeContainer2 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect2, useMemo as useMemo3 } from "react";
+import { useEffect, useMemo as useMemo2 } from "react";
 import { Checkerboard } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData2 } from "@awesome-flow/core/hooks";
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function NoiseCheckerboardNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData2();
-  const module = useMemo3(() => new Checkerboard(), []);
-  useEffect2(() => {
+  const module = useMemo2(() => new Checkerboard(), []);
+  useEffect(() => {
     updateComputedData(id, { module });
   }, [id, module, updateComputedData]);
-  return /* @__PURE__ */ jsx5(NodeContainer2, { id, selected, data, type });
+  return /* @__PURE__ */ jsx2(NodeContainer2, { id, selected, data, type });
 }
 var noise_checkerboard_node_default = NoiseCheckerboardNode;
 
 // src/nodes/generators/noise-const-node.tsx
 import { NodeContainer as NodeContainer3 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect3, useMemo as useMemo4, useState as useState2 } from "react";
-import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData3, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
+import { useEffect as useEffect2, useMemo as useMemo3, useState } from "react";
+import { Group, NumberInput, Stack } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData3, useUpdateNodeData } from "@awesome-flow/core/hooks";
 import { Const } from "libnoise-ts/module/generator";
-import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function NoiseConstNode({ id, selected, data, type }) {
-  const [min, setMin] = useState2(data.min);
-  const [max, setMax] = useState2(data.max);
-  const [noise, setNoise] = useState2(data.noise);
-  const updateNodeData = useUpdateNodeData2();
+  const [min, setMin] = useState(data.min);
+  const [max, setMax] = useState(data.max);
+  const [noise, setNoise] = useState(data.noise);
+  const updateNodeData = useUpdateNodeData();
   const updateComputedData = useUpdateNodeComputedData3();
-  const module = useMemo4(() => new Const(), []);
-  useEffect3(() => {
+  const module = useMemo3(() => new Const(), []);
+  useEffect2(() => {
     module.value = noise;
     updateNodeData(id, { noise, min, max });
     updateComputedData(id, { module });
   }, [noise, min, max, module, updateNodeData, id, updateComputedData]);
-  return /* @__PURE__ */ jsx6(NodeContainer3, { id, selected, data, type, children: /* @__PURE__ */ jsxs3(Stack2, { children: [
-    /* @__PURE__ */ jsxs3(Group2, { children: [
-      /* @__PURE__ */ jsx6(NumberInput2, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
-      /* @__PURE__ */ jsx6(NumberInput2, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
+  return /* @__PURE__ */ jsx3(NodeContainer3, { id, selected, data, type, children: /* @__PURE__ */ jsxs2(Stack, { children: [
+    /* @__PURE__ */ jsxs2(Group, { children: [
+      /* @__PURE__ */ jsx3(NumberInput, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
+      /* @__PURE__ */ jsx3(NumberInput, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs3(Group2, { children: [
+    /* @__PURE__ */ jsxs2(Group, { children: [
       "noise:",
-      /* @__PURE__ */ jsx6(
-        NumberInput2,
+      /* @__PURE__ */ jsx3(
+        NumberInput,
         {
           size: "xs",
           value: noise,
@@ -227,14 +84,15 @@ var noise_const_node_default = NoiseConstNode;
 
 // src/nodes/generators/noise-cylinders-node.tsx
 import { NodeContainer as NodeContainer4, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback3, useMemo as useMemo5 } from "react";
+import { useCallback as useCallback2, useMemo as useMemo4 } from "react";
 import { Cylinders } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData4 } from "@awesome-flow/core/hooks";
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables2 } from "@awesome-flow/core/components";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 function NoiseCylindersNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData4();
-  const module = useMemo5(() => new Cylinders(), []);
-  const onPropertiesChange = useCallback3(
+  const module = useMemo4(() => new Cylinders(), []);
+  const onPropertiesChange = useCallback2(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -243,23 +101,24 @@ function NoiseCylindersNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs4(NodeContainer4, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx7(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx7(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs3(NodeContainer4, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx4(NodePropertyVariables2, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx4(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_cylinders_node_default = NoiseCylindersNode;
 
 // src/nodes/generators/noise-perlin-node.tsx
 import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback4, useMemo as useMemo6 } from "react";
+import { useCallback as useCallback3, useMemo as useMemo5 } from "react";
 import { Perlin } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData5 } from "@awesome-flow/core/hooks";
-import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables3 } from "@awesome-flow/core/components";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function NoisePerlinNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData5();
-  const module = useMemo6(() => new Perlin(), []);
-  const onPropertiesChange = useCallback4(
+  const module = useMemo5(() => new Perlin(), []);
+  const onPropertiesChange = useCallback3(
     (properties) => {
       Object.keys(properties).forEach((k) => {
         module[k] = properties[k].value;
@@ -268,36 +127,37 @@ function NoisePerlinNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs5(NodeContainer5, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx8(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx8(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs4(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx5(NodePropertyVariables3, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_perlin_node_default = NoisePerlinNode;
 
 // src/nodes/generators/noise-ridgedmulti-node.tsx
 import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback5, useMemo as useMemo7 } from "react";
+import { useCallback as useCallback4, useMemo as useMemo6 } from "react";
 import { RidgedMulti } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables4 } from "@awesome-flow/core/components";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function NoiseRidgedMultiNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData6();
-  const module = useMemo7(() => new RidgedMulti(), []);
-  const onPropertiesChange = useCallback5((properties) => {
+  const module = useMemo6(() => new RidgedMulti(), []);
+  const onPropertiesChange = useCallback4((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs6(NodeContainer6, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx9(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx9(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs5(NodeContainer6, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx6(NodePropertyVariables4, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx6(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_ridgedmulti_node_default = NoiseRidgedMultiNode;
 
 // src/nodes/generators/noise-simplex-node.tsx
 import { NodeContainer as NodeContainer7 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect4, useMemo as useMemo8 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo7 } from "react";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
 
 // src/modules/simplex-module.ts
@@ -315,46 +175,48 @@ var SimplexModule = class extends Module {
 };
 
 // src/nodes/generators/noise-simplex-node.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 function NoiseSimplexNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData7();
-  const module = useMemo8(() => new SimplexModule(), []);
-  useEffect4(() => {
+  const module = useMemo7(() => new SimplexModule(), []);
+  useEffect3(() => {
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsx10(NodeContainer7, { id, selected, data, type });
+  return /* @__PURE__ */ jsx7(NodeContainer7, { id, selected, data, type });
 }
 var noise_simplex_node_default = NoiseSimplexNode;
 
 // src/nodes/generators/noise-spheres-node.tsx
 import { NodeContainer as NodeContainer8, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback6, useMemo as useMemo9 } from "react";
+import { useCallback as useCallback5, useMemo as useMemo8 } from "react";
 import { Spheres } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData8 } from "@awesome-flow/core/hooks";
-import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables5 } from "@awesome-flow/core/components";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 function NoiseSpheresNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData8();
-  const module = useMemo9(() => new Spheres(), []);
-  const onPropertiesChange = useCallback6((properties) => {
+  const module = useMemo8(() => new Spheres(), []);
+  const onPropertiesChange = useCallback5((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs7(NodeContainer8, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx11(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx11(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs6(NodeContainer8, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx8(NodePropertyVariables5, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx8(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_spheres_node_default = NoiseSpheresNode;
 
 // src/nodes/generators/noise-voronoi-node.tsx
 import { NodeContainer as NodeContainer9, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback6 } from "react";
 import { Voronoi } from "libnoise-ts/module/generator";
 import { useUpdateNodeComputedData as useUpdateNodeComputedData9 } from "@awesome-flow/core/hooks";
-import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+import { NodePropertyVariables as NodePropertyVariables6 } from "@awesome-flow/core/components";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function NoiseVoronoiNode({ id, selected, data, type }) {
   const updateComputedData = useUpdateNodeComputedData9();
-  const onPropertiesChange = useCallback7(
+  const onPropertiesChange = useCallback6(
     (properties) => {
       const module = new Voronoi(
         properties.frequency.value,
@@ -366,27 +228,27 @@ function NoiseVoronoiNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs8(NodeContainer9, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx12(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx12(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs7(NodeContainer9, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx9(NodePropertyVariables6, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx9(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_voronoi_node_default = NoiseVoronoiNode;
 
 // src/nodes/generators/position-const-node.tsx
 import { NodeContainer as NodeContainer10 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect5, useState as useState3 } from "react";
-import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData10, useUpdateNodeData as useUpdateNodeData3 } from "@awesome-flow/core/hooks";
-import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+import { useEffect as useEffect4, useState as useState2 } from "react";
+import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData10, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 function PositionConstNode({ id, selected, data, type }) {
   const position = data.position ?? { x: 0, y: 0, z: 0 };
-  const [x, setX] = useState3(position.x);
-  const [y, setY] = useState3(position.y);
-  const [z, setZ] = useState3(position.z);
-  const updateNodeData = useUpdateNodeData3();
+  const [x, setX] = useState2(position.x);
+  const [y, setY] = useState2(position.y);
+  const [z, setZ] = useState2(position.z);
+  const updateNodeData = useUpdateNodeData2();
   const updateComputedData = useUpdateNodeComputedData10();
-  useEffect5(() => {
+  useEffect4(() => {
     const position2 = { x, y, z };
     updateNodeData(id, {
       position: position2
@@ -395,18 +257,18 @@ function PositionConstNode({ id, selected, data, type }) {
       positions: [position2]
     });
   }, [x, y, z]);
-  return /* @__PURE__ */ jsx13(NodeContainer10, { id, selected, data, type, children: /* @__PURE__ */ jsxs9(Stack3, { children: [
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+  return /* @__PURE__ */ jsx10(NodeContainer10, { id, selected, data, type, children: /* @__PURE__ */ jsxs8(Stack2, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "x: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "y: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs9(Group3, { children: [
+    /* @__PURE__ */ jsxs8(Group2, { children: [
       "z: ",
-      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx10(NumberInput2, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] })
   ] }) });
 }
@@ -414,28 +276,28 @@ var position_const_node_default = PositionConstNode;
 
 // src/nodes/generators/position-grid-node.tsx
 import { NodeContainer as NodeContainer11 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect6, useState as useState4 } from "react";
-import { Group as Group4, NumberInput as NumberInput4, Stack as Stack4 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData11, useUpdateNodeData as useUpdateNodeData4 } from "@awesome-flow/core/hooks";
-import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+import { useEffect as useEffect5, useState as useState3 } from "react";
+import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData11, useUpdateNodeData as useUpdateNodeData3 } from "@awesome-flow/core/hooks";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 function PositionGridNode({ id, selected, data, type }) {
-  const [x, setX] = useState4(data.center?.x);
-  const [y, setY] = useState4(data.center?.y);
-  const [z, setZ] = useState4(data.center?.z);
-  const [radius, setRadius] = useState4(data.radius);
-  const updateNodeData = useUpdateNodeData4();
+  const [x, setX] = useState3(data.center?.x);
+  const [y, setY] = useState3(data.center?.y);
+  const [z, setZ] = useState3(data.center?.z);
+  const [radius, setRadius] = useState3(data.radius);
+  const updateNodeData = useUpdateNodeData3();
   const updateComputedData = useUpdateNodeComputedData11();
-  useEffect6(() => {
+  useEffect5(() => {
     updateNodeData(id, {
       center: { x, y, z }
     });
   }, [x, y, z]);
-  useEffect6(() => {
+  useEffect5(() => {
     updateNodeData(id, {
       radius
     });
   }, [radius]);
-  useEffect6(() => {
+  useEffect5(() => {
     const positions = [];
     for (let i = -radius; i < radius; i++) {
       for (let j = -radius; j < radius; j++) {
@@ -446,134 +308,26 @@ function PositionGridNode({ id, selected, data, type }) {
       positions
     });
   }, [x, y, z, radius]);
-  return /* @__PURE__ */ jsx14(NodeContainer11, { id, selected, data, type, children: /* @__PURE__ */ jsxs10(Stack4, { children: [
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+  return /* @__PURE__ */ jsx11(NodeContainer11, { id, selected, data, type, children: /* @__PURE__ */ jsxs9(Stack3, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "x: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "y: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "z: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Group4, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
       "r: ",
-      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
+      /* @__PURE__ */ jsx11(NumberInput3, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
     ] })
   ] }) });
 }
 var position_grid_node_default = PositionGridNode;
-
-// src/nodes/generators/variable-property-node.tsx
-import { NodeCombobox, NodeContainer as NodeContainer12, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback8, useEffect as useEffect7, useState as useState5 } from "react";
-import { Stack as Stack5 } from "@mantine/core";
-import { useIncomingNodeData as useIncomingNodeData2, useOutgoingNodes, useUpdateNodeData as useUpdateNodeData5 } from "@awesome-flow/core/hooks";
-import { getObjectPropertyMap } from "@awesome-flow/core/utils";
-import { nodeDataPropertyExcept as nodeDataPropertyExcept3 } from "@awesome-flow/core/abstract";
-import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
-function VariablePropertyNode({
-  id,
-  selected,
-  data,
-  type
-}) {
-  const [options, setOptions] = useState5({});
-  const [selectedProperty, setSelectedProperty] = useState5(data.property);
-  const updateNodeData = useUpdateNodeData5();
-  const outgoing = useOutgoingNodes(id);
-  const incoming = useIncomingNodeData2(id);
-  useEffect7(() => {
-    if (outgoing?.length) {
-      const { data: data2 } = outgoing[0];
-      const properties = getObjectPropertyMap(data2, nodeDataPropertyExcept3);
-      setOptions(properties);
-      if (!selectedProperty) {
-        const keys = Object.keys(properties);
-        if (keys.length) {
-          setSelectedProperty({
-            name: keys[0],
-            value: properties[keys[0]]
-          });
-        }
-      }
-    } else {
-      setSelectedProperty(null);
-    }
-  }, [outgoing]);
-  useEffect7(() => {
-    if (!incoming?.length && selectedProperty?.disabled) {
-      setSelectedProperty({ ...selectedProperty, disabled: false });
-    } else if (incoming?.length && selectedProperty) {
-      const incomingValue = incoming[0].value;
-      if (incomingValue !== void 0 && incomingValue !== null) {
-        setSelectedProperty({
-          name: selectedProperty.name,
-          value: incomingValue,
-          disabled: true
-        });
-      }
-    }
-  }, [incoming]);
-  useEffect7(() => {
-    if (selectedProperty) {
-      updateNodeData(id, { property: selectedProperty });
-    }
-  }, [selectedProperty]);
-  const onPropertyChange = useCallback8(
-    (selected2) => {
-      setSelectedProperty({
-        name: selected2,
-        value: options[selected2]
-      });
-    },
-    [options]
-  );
-  const onValueChange = useCallback8((name, value) => {
-    setSelectedProperty({
-      name,
-      value
-    });
-  }, []);
-  return /* @__PURE__ */ jsxs11(NodeContainer12, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsxs11(Stack5, { align: "center", children: [
-      /* @__PURE__ */ jsx15(
-        NodeCombobox,
-        {
-          options,
-          onChange: onPropertyChange,
-          selected: selectedProperty?.name,
-          hideListValues: true
-        }
-      ),
-      /* @__PURE__ */ jsx15(node_property_input_default, { property: selectedProperty, onChange: onValueChange })
-    ] }),
-    /* @__PURE__ */ jsx15(NodeTrackConnections7, { handles: data.handles, nodeId: id })
-  ] });
-}
-var variable_property_node_default = VariablePropertyNode;
-
-// src/nodes/generators/variable-value-node.tsx
-import { NodeContainer as NodeContainer13, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback9, useState as useState6 } from "react";
-import { useUpdateNodeData as useUpdateNodeData6 } from "@awesome-flow/core/hooks";
-import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
-function VariableValueNode({ id, selected, data, type }) {
-  const [value, setValue] = useState6(data.value || 0);
-  const updateNodeData = useUpdateNodeData6();
-  const onValueChange = useCallback9((newValue) => {
-    updateNodeData(id, { value: newValue });
-    setValue(newValue);
-  }, []);
-  return /* @__PURE__ */ jsxs12(NodeContainer13, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx16(node_value_input_default, { value, onChange: onValueChange }),
-    /* @__PURE__ */ jsx16(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "source" })
-  ] });
-}
-var variable_value_node_default = VariableValueNode;
 export {
   noise_billow_node_default as NoiseBillowNode,
   noise_checkerboard_node_default as NoiseCheckerboardNode,
@@ -585,8 +339,5 @@ export {
   noise_spheres_node_default as NoiseSpheresNode,
   noise_voronoi_node_default as NoiseVoronoiNode,
   position_const_node_default as PositionConstNode,
-  position_grid_node_default as PositionGridNode,
-  variable_property_node_default as VariablePropertyNode,
-  variable_value_node_default as VariableValueNode
+  position_grid_node_default as PositionGridNode
 };
-//# sourceMappingURL=index.js.map