@awesome-flow/noise 0.1.0

package/dist/nodes/generators/index.js

@@ -0,0 +1,592 @@
+// 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 { 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";
+function NoiseBillowNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData();
+  const module = useMemo2(() => new Billow(), []);
+  const onPropertiesChange = useCallback2(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [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" })
+  ] });
+}
+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 { Checkerboard } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData2 } from "@awesome-flow/core/hooks";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function NoiseCheckerboardNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData2();
+  const module = useMemo3(() => new Checkerboard(), []);
+  useEffect2(() => {
+    updateComputedData(id, { module });
+  }, [id, module, updateComputedData]);
+  return /* @__PURE__ */ jsx5(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 { Const } from "libnoise-ts/module/generator";
+import { jsx as jsx6, jsxs as jsxs3 } 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 updateComputedData = useUpdateNodeComputedData3();
+  const module = useMemo4(() => new Const(), []);
+  useEffect3(() => {
+    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)) })
+    ] }),
+    /* @__PURE__ */ jsxs3(Group2, { children: [
+      "noise:",
+      /* @__PURE__ */ jsx6(
+        NumberInput2,
+        {
+          size: "xs",
+          value: noise,
+          onChange: (e) => setNoise(Number(e)),
+          max,
+          min,
+          step: 0.1
+        }
+      )
+    ] })
+  ] }) });
+}
+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 { 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";
+function NoiseCylindersNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData4();
+  const module = useMemo5(() => new Cylinders(), []);
+  const onPropertiesChange = useCallback3(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [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" })
+  ] });
+}
+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 { 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";
+function NoisePerlinNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData5();
+  const module = useMemo6(() => new Perlin(), []);
+  const onPropertiesChange = useCallback4(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [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" })
+  ] });
+}
+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 { 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";
+function NoiseRidgedMultiNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData6();
+  const module = useMemo7(() => new RidgedMulti(), []);
+  const onPropertiesChange = useCallback5((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" })
+  ] });
+}
+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 { useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
+
+// src/modules/simplex-module.ts
+import Module from "libnoise-ts/module/Module";
+import { createNoise3D } from "simplex-noise";
+var SimplexModule = class extends Module {
+  noise;
+  constructor(random) {
+    super();
+    this.noise = createNoise3D(random);
+  }
+  getValue(x, y, z) {
+    return this.noise(x, y, z);
+  }
+};
+
+// src/nodes/generators/noise-simplex-node.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function NoiseSimplexNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData7();
+  const module = useMemo8(() => new SimplexModule(), []);
+  useEffect4(() => {
+    updateComputedData(id, { module });
+  }, []);
+  return /* @__PURE__ */ jsx10(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 { 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";
+function NoiseSpheresNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData8();
+  const module = useMemo9(() => new Spheres(), []);
+  const onPropertiesChange = useCallback6((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" })
+  ] });
+}
+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 { 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";
+function NoiseVoronoiNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData9();
+  const onPropertiesChange = useCallback7(
+    (properties) => {
+      const module = new Voronoi(
+        properties.frequency.value,
+        properties.displacement.value,
+        properties.distance.value,
+        properties.seed.value
+      );
+      updateComputedData(id, { module });
+    },
+    []
+  );
+  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" })
+  ] });
+}
+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";
+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 updateComputedData = useUpdateNodeComputedData10();
+  useEffect5(() => {
+    const position2 = { x, y, z };
+    updateNodeData(id, {
+      position: position2
+    });
+    updateComputedData(id, {
+      positions: [position2]
+    });
+  }, [x, y, z]);
+  return /* @__PURE__ */ jsx13(NodeContainer10, { id, selected, data, type, children: /* @__PURE__ */ jsxs9(Stack3, { children: [
+    /* @__PURE__ */ jsxs9(Group3, { children: [
+      "x: ",
+      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+    ] }),
+    /* @__PURE__ */ jsxs9(Group3, { children: [
+      "y: ",
+      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+    ] }),
+    /* @__PURE__ */ jsxs9(Group3, { children: [
+      "z: ",
+      /* @__PURE__ */ jsx13(NumberInput3, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+    ] })
+  ] }) });
+}
+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";
+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 updateComputedData = useUpdateNodeComputedData11();
+  useEffect6(() => {
+    updateNodeData(id, {
+      center: { x, y, z }
+    });
+  }, [x, y, z]);
+  useEffect6(() => {
+    updateNodeData(id, {
+      radius
+    });
+  }, [radius]);
+  useEffect6(() => {
+    const positions = [];
+    for (let i = -radius; i < radius; i++) {
+      for (let j = -radius; j < radius; j++) {
+        positions.push({ x: x + i, y: y + j, z });
+      }
+    }
+    updateComputedData(id, {
+      positions
+    });
+  }, [x, y, z, radius]);
+  return /* @__PURE__ */ jsx14(NodeContainer11, { id, selected, data, type, children: /* @__PURE__ */ jsxs10(Stack4, { children: [
+    /* @__PURE__ */ jsxs10(Group4, { children: [
+      "x: ",
+      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+    ] }),
+    /* @__PURE__ */ jsxs10(Group4, { children: [
+      "y: ",
+      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+    ] }),
+    /* @__PURE__ */ jsxs10(Group4, { children: [
+      "z: ",
+      /* @__PURE__ */ jsx14(NumberInput4, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+    ] }),
+    /* @__PURE__ */ jsxs10(Group4, { children: [
+      "r: ",
+      /* @__PURE__ */ jsx14(NumberInput4, { 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,
+  noise_const_node_default as NoiseConstNode,
+  noise_cylinders_node_default as NoiseCylindersNode,
+  noise_perlin_node_default as NoisePerlinNode,
+  noise_ridgedmulti_node_default as NoiseRidgedMultiNode,
+  noise_simplex_node_default as NoiseSimplexNode,
+  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
+};
+//# sourceMappingURL=index.js.map