@awesome-flow/noise 0.1.0

package/dist/nodes/generators/index.cjs

@@ -0,0 +1,640 @@
+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);
+
+// src/nodes/generators/index.ts
+var generators_exports = {};
+__export(generators_exports, {
+  NoiseBillowNode: () => noise_billow_node_default,
+  NoiseCheckerboardNode: () => noise_checkerboard_node_default,
+  NoiseConstNode: () => noise_const_node_default,
+  NoiseCylindersNode: () => noise_cylinders_node_default,
+  NoisePerlinNode: () => noise_perlin_node_default,
+  NoiseRidgedMultiNode: () => noise_ridgedmulti_node_default,
+  NoiseSimplexNode: () => noise_simplex_node_default,
+  NoiseSpheresNode: () => noise_spheres_node_default,
+  NoiseVoronoiNode: () => noise_voronoi_node_default,
+  PositionConstNode: () => position_const_node_default,
+  PositionGridNode: () => position_grid_node_default,
+  VariablePropertyNode: () => variable_property_node_default,
+  VariableValueNode: () => variable_value_node_default
+});
+module.exports = __toCommonJS(generators_exports);
+
+// src/nodes/generators/noise-billow-node.tsx
+var import_layout = require("@awesome-flow/core/layout");
+var import_react2 = require("react");
+var import_generator = require("libnoise-ts/module/generator");
+var import_hooks2 = require("@awesome-flow/core/hooks");
+var import_abstract2 = require("@awesome-flow/core/abstract");
+
+// src/layout/node-property-variables.tsx
+var import_hooks = require("@awesome-flow/core/hooks");
+var import_react = require("react");
+var import_core2 = require("@mantine/core");
+var import_utils = require("@awesome-flow/core/utils");
+var import_abstract = require("@awesome-flow/core/abstract");
+
+// src/layout/node-value-input.tsx
+var import_core = require("@mantine/core");
+var import_jsx_runtime = require("react/jsx-runtime");
+function NodeValueInput({ value, disabled, step, onChange }) {
+  if (value === void 0 || value === null) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {});
+  }
+  switch (typeof value) {
+    case "boolean": {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_core.Switch,
+        {
+          checked: value,
+          disabled,
+          onChange: (e) => onChange(e.currentTarget.checked)
+        }
+      );
+    }
+    case "number": {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_core.NumberInput, { value, disabled, step, onChange: (e) => onChange(e) });
+    }
+    case "string": {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_core.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
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function NodePropertyInput({ property, onChange }) {
+  if (!property) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    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
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function NodePropertyVariables({
+  data,
+  nodeId,
+  onPropertiesChange,
+  except = import_abstract.nodeDataPropertyExcept
+}) {
+  const [properties, setProperties] = (0, import_react.useState)(() => {
+    const keys = (0, import_utils.getObjectKeys)(data, except);
+    const dataProps = {};
+    for (const key of keys) {
+      dataProps[key] = {
+        name: key,
+        value: data[key]
+      };
+    }
+    return dataProps;
+  });
+  const updateNodeData = (0, import_hooks.useUpdateNodeData)();
+  const incoming = (0, import_hooks.useIncomingNodeData)(nodeId);
+  const resetAllDisabled = (0, import_react.useCallback)(() => {
+    const keys = Object.keys(properties);
+    keys.forEach((k) => {
+      properties[k].disabled = false;
+    });
+    setProperties(properties);
+  }, []);
+  const updatePropertyValue = (0, import_react.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 });
+  }, []);
+  (0, import_react.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]);
+  (0, import_react.useEffect)(() => {
+    if (onPropertiesChange) {
+      onPropertiesChange(properties);
+    }
+  }, [onPropertiesChange, properties]);
+  const nodes = (0, import_react.useMemo)(() => {
+    return Object.keys(properties).map((key) => {
+      const property = properties[key];
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_core2.Group, { children: [
+        property.name,
+        ":",
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(node_property_input_default, { property, onChange: updatePropertyValue })
+      ] }, key);
+    });
+  }, [properties, updatePropertyValue]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_core2.Stack, { children: nodes });
+}
+var node_property_variables_default = NodePropertyVariables;
+
+// src/nodes/generators/noise-billow-node.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function NoiseBillowNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks2.useUpdateNodeComputedData)();
+  const module2 = (0, import_react2.useMemo)(() => new import_generator.Billow(), []);
+  const onPropertiesChange = (0, import_react2.useCallback)(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module2[k] = properties[k].value;
+      });
+      updateComputedData(id, { module: module2 });
+    },
+    [id, module2, updateComputedData]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      node_property_variables_default,
+      {
+        data,
+        except: import_abstract2.nodeDataPropertyExcept,
+        nodeId: id,
+        onPropertiesChange
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_billow_node_default = NoiseBillowNode;
+
+// src/nodes/generators/noise-checkerboard-node.tsx
+var import_layout2 = require("@awesome-flow/core/layout");
+var import_react3 = require("react");
+var import_generator2 = require("libnoise-ts/module/generator");
+var import_hooks3 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function NoiseCheckerboardNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks3.useUpdateNodeComputedData)();
+  const module2 = (0, import_react3.useMemo)(() => new import_generator2.Checkerboard(), []);
+  (0, import_react3.useEffect)(() => {
+    updateComputedData(id, { module: module2 });
+  }, [id, module2, updateComputedData]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_layout2.NodeContainer, { id, selected, data, type });
+}
+var noise_checkerboard_node_default = NoiseCheckerboardNode;
+
+// src/nodes/generators/noise-const-node.tsx
+var import_layout3 = require("@awesome-flow/core/layout");
+var import_react4 = require("react");
+var import_core3 = require("@mantine/core");
+var import_hooks4 = require("@awesome-flow/core/hooks");
+var import_generator3 = require("libnoise-ts/module/generator");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function NoiseConstNode({ id, selected, data, type }) {
+  const [min, setMin] = (0, import_react4.useState)(data.min);
+  const [max, setMax] = (0, import_react4.useState)(data.max);
+  const [noise, setNoise] = (0, import_react4.useState)(data.noise);
+  const updateNodeData = (0, import_hooks4.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks4.useUpdateNodeComputedData)();
+  const module2 = (0, import_react4.useMemo)(() => new import_generator3.Const(), []);
+  (0, import_react4.useEffect)(() => {
+    module2.value = noise;
+    updateNodeData(id, { noise, min, max });
+    updateComputedData(id, { module: module2 });
+  }, [noise, min, max, module2, updateNodeData, id, updateComputedData]);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_layout3.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_core3.Stack, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_core3.Group, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_core3.NumberInput, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_core3.NumberInput, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_core3.Group, { children: [
+      "noise:",
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        import_core3.NumberInput,
+        {
+          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
+var import_layout4 = require("@awesome-flow/core/layout");
+var import_react5 = require("react");
+var import_generator4 = require("libnoise-ts/module/generator");
+var import_hooks5 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function NoiseCylindersNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks5.useUpdateNodeComputedData)();
+  const module2 = (0, import_react5.useMemo)(() => new import_generator4.Cylinders(), []);
+  const onPropertiesChange = (0, import_react5.useCallback)(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module2[k] = properties[k].value;
+      });
+      updateComputedData(id, { module: module2 });
+    },
+    [id, module2, updateComputedData]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_layout4.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_layout4.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_cylinders_node_default = NoiseCylindersNode;
+
+// src/nodes/generators/noise-perlin-node.tsx
+var import_layout5 = require("@awesome-flow/core/layout");
+var import_react6 = require("react");
+var import_generator5 = require("libnoise-ts/module/generator");
+var import_hooks6 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function NoisePerlinNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks6.useUpdateNodeComputedData)();
+  const module2 = (0, import_react6.useMemo)(() => new import_generator5.Perlin(), []);
+  const onPropertiesChange = (0, import_react6.useCallback)(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module2[k] = properties[k].value;
+      });
+      updateComputedData(id, { module: module2 });
+    },
+    [id, module2, updateComputedData]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_layout5.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_layout5.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_perlin_node_default = NoisePerlinNode;
+
+// src/nodes/generators/noise-ridgedmulti-node.tsx
+var import_layout6 = require("@awesome-flow/core/layout");
+var import_react7 = require("react");
+var import_generator6 = require("libnoise-ts/module/generator");
+var import_hooks7 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function NoiseRidgedMultiNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks7.useUpdateNodeComputedData)();
+  const module2 = (0, import_react7.useMemo)(() => new import_generator6.RidgedMulti(), []);
+  const onPropertiesChange = (0, import_react7.useCallback)((properties) => {
+    Object.keys(properties).forEach((k) => module2[k] = properties[k].value);
+    updateComputedData(id, { module: module2 });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_layout6.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_layout6.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_ridgedmulti_node_default = NoiseRidgedMultiNode;
+
+// src/nodes/generators/noise-simplex-node.tsx
+var import_layout7 = require("@awesome-flow/core/layout");
+var import_react8 = require("react");
+var import_hooks8 = require("@awesome-flow/core/hooks");
+
+// src/modules/simplex-module.ts
+var import_Module = __toESM(require("libnoise-ts/module/Module"), 1);
+var import_simplex_noise = require("simplex-noise");
+var SimplexModule = class extends import_Module.default {
+  noise;
+  constructor(random) {
+    super();
+    this.noise = (0, import_simplex_noise.createNoise3D)(random);
+  }
+  getValue(x, y, z) {
+    return this.noise(x, y, z);
+  }
+};
+
+// src/nodes/generators/noise-simplex-node.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function NoiseSimplexNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks8.useUpdateNodeComputedData)();
+  const module2 = (0, import_react8.useMemo)(() => new SimplexModule(), []);
+  (0, import_react8.useEffect)(() => {
+    updateComputedData(id, { module: module2 });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_layout7.NodeContainer, { id, selected, data, type });
+}
+var noise_simplex_node_default = NoiseSimplexNode;
+
+// src/nodes/generators/noise-spheres-node.tsx
+var import_layout8 = require("@awesome-flow/core/layout");
+var import_react9 = require("react");
+var import_generator7 = require("libnoise-ts/module/generator");
+var import_hooks9 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function NoiseSpheresNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks9.useUpdateNodeComputedData)();
+  const module2 = (0, import_react9.useMemo)(() => new import_generator7.Spheres(), []);
+  const onPropertiesChange = (0, import_react9.useCallback)((properties) => {
+    Object.keys(properties).forEach((k) => module2[k] = properties[k].value);
+    updateComputedData(id, { module: module2 });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_layout8.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_layout8.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_spheres_node_default = NoiseSpheresNode;
+
+// src/nodes/generators/noise-voronoi-node.tsx
+var import_layout9 = require("@awesome-flow/core/layout");
+var import_react10 = require("react");
+var import_generator8 = require("libnoise-ts/module/generator");
+var import_hooks10 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+function NoiseVoronoiNode({ id, selected, data, type }) {
+  const updateComputedData = (0, import_hooks10.useUpdateNodeComputedData)();
+  const onPropertiesChange = (0, import_react10.useCallback)(
+    (properties) => {
+      const module2 = new import_generator8.Voronoi(
+        properties.frequency.value,
+        properties.displacement.value,
+        properties.distance.value,
+        properties.seed.value
+      );
+      updateComputedData(id, { module: module2 });
+    },
+    []
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_layout9.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_layout9.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_voronoi_node_default = NoiseVoronoiNode;
+
+// src/nodes/generators/position-const-node.tsx
+var import_layout10 = require("@awesome-flow/core/layout");
+var import_react11 = require("react");
+var import_core4 = require("@mantine/core");
+var import_hooks11 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function PositionConstNode({ id, selected, data, type }) {
+  const position = data.position ?? { x: 0, y: 0, z: 0 };
+  const [x, setX] = (0, import_react11.useState)(position.x);
+  const [y, setY] = (0, import_react11.useState)(position.y);
+  const [z, setZ] = (0, import_react11.useState)(position.z);
+  const updateNodeData = (0, import_hooks11.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks11.useUpdateNodeComputedData)();
+  (0, import_react11.useEffect)(() => {
+    const position2 = { x, y, z };
+    updateNodeData(id, {
+      position: position2
+    });
+    updateComputedData(id, {
+      positions: [position2]
+    });
+  }, [x, y, z]);
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_layout10.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_core4.Stack, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_core4.Group, { children: [
+      "x: ",
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_core4.NumberInput, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_core4.Group, { children: [
+      "y: ",
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_core4.NumberInput, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_core4.Group, { children: [
+      "z: ",
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_core4.NumberInput, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+    ] })
+  ] }) });
+}
+var position_const_node_default = PositionConstNode;
+
+// src/nodes/generators/position-grid-node.tsx
+var import_layout11 = require("@awesome-flow/core/layout");
+var import_react12 = require("react");
+var import_core5 = require("@mantine/core");
+var import_hooks12 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function PositionGridNode({ id, selected, data, type }) {
+  const [x, setX] = (0, import_react12.useState)(data.center?.x);
+  const [y, setY] = (0, import_react12.useState)(data.center?.y);
+  const [z, setZ] = (0, import_react12.useState)(data.center?.z);
+  const [radius, setRadius] = (0, import_react12.useState)(data.radius);
+  const updateNodeData = (0, import_hooks12.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks12.useUpdateNodeComputedData)();
+  (0, import_react12.useEffect)(() => {
+    updateNodeData(id, {
+      center: { x, y, z }
+    });
+  }, [x, y, z]);
+  (0, import_react12.useEffect)(() => {
+    updateNodeData(id, {
+      radius
+    });
+  }, [radius]);
+  (0, import_react12.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime14.jsx)(import_layout11.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core5.Stack, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core5.Group, { children: [
+      "x: ",
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_core5.NumberInput, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core5.Group, { children: [
+      "y: ",
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_core5.NumberInput, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core5.Group, { children: [
+      "z: ",
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_core5.NumberInput, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core5.Group, { children: [
+      "r: ",
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_core5.NumberInput, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
+    ] })
+  ] }) });
+}
+var position_grid_node_default = PositionGridNode;
+
+// src/nodes/generators/variable-property-node.tsx
+var import_layout12 = require("@awesome-flow/core/layout");
+var import_react13 = require("react");
+var import_core6 = require("@mantine/core");
+var import_hooks13 = require("@awesome-flow/core/hooks");
+var import_utils2 = require("@awesome-flow/core/utils");
+var import_abstract3 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function VariablePropertyNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [options, setOptions] = (0, import_react13.useState)({});
+  const [selectedProperty, setSelectedProperty] = (0, import_react13.useState)(data.property);
+  const updateNodeData = (0, import_hooks13.useUpdateNodeData)();
+  const outgoing = (0, import_hooks13.useOutgoingNodes)(id);
+  const incoming = (0, import_hooks13.useIncomingNodeData)(id);
+  (0, import_react13.useEffect)(() => {
+    if (outgoing?.length) {
+      const { data: data2 } = outgoing[0];
+      const properties = (0, import_utils2.getObjectPropertyMap)(data2, import_abstract3.nodeDataPropertyExcept);
+      setOptions(properties);
+      if (!selectedProperty) {
+        const keys = Object.keys(properties);
+        if (keys.length) {
+          setSelectedProperty({
+            name: keys[0],
+            value: properties[keys[0]]
+          });
+        }
+      }
+    } else {
+      setSelectedProperty(null);
+    }
+  }, [outgoing]);
+  (0, import_react13.useEffect)(() => {
+    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]);
+  (0, import_react13.useEffect)(() => {
+    if (selectedProperty) {
+      updateNodeData(id, { property: selectedProperty });
+    }
+  }, [selectedProperty]);
+  const onPropertyChange = (0, import_react13.useCallback)(
+    (selected2) => {
+      setSelectedProperty({
+        name: selected2,
+        value: options[selected2]
+      });
+    },
+    [options]
+  );
+  const onValueChange = (0, import_react13.useCallback)((name, value) => {
+    setSelectedProperty({
+      name,
+      value
+    });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_layout12.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_core6.Stack, { align: "center", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        import_layout12.NodeCombobox,
+        {
+          options,
+          onChange: onPropertyChange,
+          selected: selectedProperty?.name,
+          hideListValues: true
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(node_property_input_default, { property: selectedProperty, onChange: onValueChange })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_layout12.NodeTrackConnections, { handles: data.handles, nodeId: id })
+  ] });
+}
+var variable_property_node_default = VariablePropertyNode;
+
+// src/nodes/generators/variable-value-node.tsx
+var import_layout13 = require("@awesome-flow/core/layout");
+var import_react14 = require("react");
+var import_hooks14 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+function VariableValueNode({ id, selected, data, type }) {
+  const [value, setValue] = (0, import_react14.useState)(data.value || 0);
+  const updateNodeData = (0, import_hooks14.useUpdateNodeData)();
+  const onValueChange = (0, import_react14.useCallback)((newValue) => {
+    updateNodeData(id, { value: newValue });
+    setValue(newValue);
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_layout13.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(node_value_input_default, { value, onChange: onValueChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_layout13.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "source" })
+  ] });
+}
+var variable_value_node_default = VariableValueNode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoiseBillowNode,
+  NoiseCheckerboardNode,
+  NoiseConstNode,
+  NoiseCylindersNode,
+  NoisePerlinNode,
+  NoiseRidgedMultiNode,
+  NoiseSimplexNode,
+  NoiseSpheresNode,
+  NoiseVoronoiNode,
+  PositionConstNode,
+  PositionGridNode,
+  VariablePropertyNode,
+  VariableValueNode
+});
+//# sourceMappingURL=index.cjs.map