@awesome-flow/noise 0.7.0 → 0.8.0

package/dist/chunk-RDQ4BOOV.js

@@ -0,0 +1,522 @@
+import {
+  NormalizeNoiseModule
+} from "./chunk-SGHEOOLW.js";
+
+// src/nodes/modifiers/noise-abs-node.tsx
+import { useIncomingComputedData, useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
+import { NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
+import { Abs } from "libnoise-simplex-ts";
+import { useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+function NoiseAbsNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData(id);
+  const updateComputedData = useUpdateNodeComputedData();
+  useEffect(() => {
+    if (incoming?.length > 0) {
+      const module = new Abs(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ jsx(NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_abs_node_default = NoiseAbsNode;
+
+// src/nodes/modifiers/noise-clamp-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData2,
+  useUpdateNodeComputedData as useUpdateNodeComputedData2,
+  useUpdateNodeData
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer2, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
+import { Group, NumberInput, Stack } from "@mantine/core";
+import { Clamp } from "libnoise-simplex-ts";
+import { useEffect as useEffect2, useState } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function NoiseClampNode({ id, selected, data, type }) {
+  const [lowerBound, setLowerBound] = useState(data.lowerBound);
+  const [upperBound, setUpperBound] = useState(data.upperBound);
+  const incoming = useIncomingComputedData2(id);
+  const updateNodeData = useUpdateNodeData();
+  const updateComputedData = useUpdateNodeComputedData2();
+  useEffect2(() => {
+    if (incoming?.length) {
+      const module = new Clamp(incoming[0].module, lowerBound, upperBound);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { lowerBound, upperBound });
+  }, [incoming, lowerBound, upperBound]);
+  return /* @__PURE__ */ jsxs(NodeContainer2, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx2(Stack, { children: /* @__PURE__ */ jsxs(Group, { children: [
+      /* @__PURE__ */ jsx2(
+        NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: lowerBound,
+          onChange: (e) => setLowerBound(Number(e)),
+          step: 0.1
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: upperBound,
+          onChange: (e) => setUpperBound(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_clamp_node_default = NoiseClampNode;
+
+// src/nodes/modifiers/noise-combine-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData3,
+  useUpdateNodeComputedData as useUpdateNodeComputedData3,
+  useUpdateNodeData as useUpdateNodeData2
+} from "@awesome-flow/core/hooks";
+import { NodeCombobox, NodeContainer as NodeContainer3, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
+import {
+  IconAsterisk,
+  IconChevronLeft,
+  IconChevronRight,
+  IconChevronUp,
+  IconPlus
+} from "@tabler/icons-react";
+import { useCallback, useEffect as useEffect3 } from "react";
+
+// src/abstract/operations.ts
+import { Add, Max, Min, Multiply, Power } from "libnoise-simplex-ts";
+var NoiseCombineType = /* @__PURE__ */ ((NoiseCombineType3) => {
+  NoiseCombineType3["add"] = "add";
+  NoiseCombineType3["max"] = "max";
+  NoiseCombineType3["min"] = "min";
+  NoiseCombineType3["multiply"] = "multiply";
+  NoiseCombineType3["power"] = "power";
+  return NoiseCombineType3;
+})(NoiseCombineType || {});
+var noiseCombineModuleMap = {
+  ["add" /* add */]: Add,
+  ["max" /* max */]: Max,
+  ["min" /* min */]: Min,
+  ["multiply" /* multiply */]: Multiply,
+  ["power" /* power */]: Power
+};
+
+// src/nodes/modifiers/noise-combine-node.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var options = {
+  add: /* @__PURE__ */ jsx3(IconPlus, {}),
+  min: /* @__PURE__ */ jsx3(IconChevronLeft, {}),
+  max: /* @__PURE__ */ jsx3(IconChevronRight, {}),
+  multiply: /* @__PURE__ */ jsx3(IconAsterisk, {}),
+  power: /* @__PURE__ */ jsx3(IconChevronUp, {})
+};
+function NoiseCombineNode({ id, selected, data, type }) {
+  const updateNodeData = useUpdateNodeData2();
+  const updateComputedData = useUpdateNodeComputedData3();
+  const incoming = useIncomingComputedData3(id);
+  useEffect3(() => {
+    const ModuleFactory = noiseCombineModuleMap[data.operation];
+    if (incoming?.length > 1) {
+      const module = new ModuleFactory(incoming[0].module, incoming[1].module);
+      updateComputedData(id, { module });
+    }
+  }, [data.operation, incoming]);
+  const onChange = useCallback((operation) => {
+    updateNodeData(id, { operation });
+  }, []);
+  return /* @__PURE__ */ jsxs2(NodeContainer3, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx3(NodeCombobox, { options, selected: data.operation, onChange, width: 150 }),
+    /* @__PURE__ */ jsx3(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_combine_node_default = NoiseCombineNode;
+
+// src/nodes/modifiers/noise-curve-node.tsx
+import { NodeState } from "@awesome-flow/core/abstract";
+import {
+  useIncomingComputedData as useIncomingComputedData4,
+  useUpdateNodeComputedData as useUpdateNodeComputedData4,
+  useUpdateNodeData as useUpdateNodeData3
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer4, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
+import { ActionIcon, Button, Group as Group2, NumberInput as NumberInput2, Space } from "@mantine/core";
+import { FORM_INDEX, useForm } from "@mantine/form";
+import { randomId } from "@mantine/hooks";
+import { IconX } from "@tabler/icons-react";
+import { Curve, Tuple } from "libnoise-simplex-ts";
+import { useCallback as useCallback2, useEffect as useEffect4, useState as useState2 } from "react";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function NoiseCurveNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData4(id);
+  const updateNodeData = useUpdateNodeData3();
+  const updateComputedData = useUpdateNodeComputedData4();
+  const [values, setValues] = useState2([]);
+  const form = useForm({
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${FORM_INDEX}.input`],
+    clearInputErrorOnChange: true,
+    validate: {
+      points: {
+        input: (value, values2) => {
+          const counts = {};
+          values2.points.forEach((x) => {
+            counts[x.input] = (counts[x.input] || 0) + 1;
+          });
+          return counts[value] > 1;
+        }
+      }
+    },
+    onValuesChange: useCallback2((values2) => {
+      form.validate();
+      if (form.isValid()) {
+        const points = values2.points.map((v) => ({ input: v.input, output: v.output }));
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+    }, [])
+  });
+  useEffect4(() => {
+    const points = data.points?.length ? data.points.map((v) => ({ input: v.input, output: v.output, key: randomId() })) : [1, 2, 3, 4].map(() => ({ input: 0, output: 0, key: randomId() }));
+    form.initialize({ points });
+  }, []);
+  useEffect4(() => {
+    if (incoming?.length && values?.length >= 4) {
+      const module = new Curve(
+        incoming[0].module,
+        values.map((p) => new Tuple(p.input, p.output))
+      );
+      updateComputedData(id, { module });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs3(Group2, { mt: "xs", children: [
+    /* @__PURE__ */ jsx4(
+      NumberInput2,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.input`),
+        step: 0.1
+      },
+      form.key(`points.${index}.input`)
+    ),
+    /* @__PURE__ */ jsx4(
+      NumberInput2,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Output Value",
+        ...form.getInputProps(`points.${index}.output`),
+        step: 0.1
+      },
+      form.key(`points.${index}.output`)
+    ),
+    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx4(
+      ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ jsx4(IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ jsxs3(NodeContainer4, { id, selected, type, data, children: [
+    fields,
+    data.state === NodeState.edit && /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx4(Space, { h: 10 }),
+      /* @__PURE__ */ jsx4(
+        Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { input: 0, output: 0, key: randomId() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx4(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_curve_node_default = NoiseCurveNode;
+
+// src/nodes/modifiers/noise-exponent-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData5,
+  useUpdateNodeComputedData as useUpdateNodeComputedData5,
+  useUpdateNodeData as useUpdateNodeData4
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
+import { Group as Group3, NumberInput as NumberInput3, Stack as Stack2 } from "@mantine/core";
+import { Exponent } from "libnoise-simplex-ts";
+import { useEffect as useEffect5, useState as useState3 } from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function NoiseExponentNode({ id, selected, data, type }) {
+  const [exponent, setExponent] = useState3(data.exponent);
+  const incoming = useIncomingComputedData5(id);
+  const updateNodeData = useUpdateNodeData4();
+  const updateComputedData = useUpdateNodeComputedData5();
+  useEffect5(() => {
+    if (incoming?.length > 0) {
+      const module = new Exponent(incoming[0].module, exponent);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { exponent });
+  }, [incoming, exponent]);
+  return /* @__PURE__ */ jsxs4(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx5(Stack2, { children: /* @__PURE__ */ jsxs4(Group3, { children: [
+      "Exponent:",
+      /* @__PURE__ */ jsx5(
+        NumberInput3,
+        {
+          size: "xs",
+          value: exponent,
+          onChange: (e) => setExponent(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_exponent_node_default = NoiseExponentNode;
+
+// src/nodes/modifiers/noise-invert-node.tsx
+import { useIncomingComputedData as useIncomingComputedData6, useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
+import { Invert } from "libnoise-simplex-ts";
+import { useEffect as useEffect6 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function NoiseInvertNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData6(id);
+  const updateComputedData = useUpdateNodeComputedData6();
+  useEffect6(() => {
+    if (incoming?.length > 0) {
+      const module = new Invert(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ jsx6(NodeContainer6, { id, selected, data, type, children: /* @__PURE__ */ jsx6(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_invert_node_default = NoiseInvertNode;
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData7,
+  useUpdateNodeComputedData as useUpdateNodeComputedData7,
+  useUpdateNodeData as useUpdateNodeData5
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer7, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
+import { Group as Group4, NumberInput as NumberInput4, Stack as Stack3 } from "@mantine/core";
+import { useEffect as useEffect7, useState as useState4 } from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function NoiseNormalizeNode({ id, selected, data, type }) {
+  const [intervalStart, setIntervalStart] = useState4(data.intervalStart);
+  const [intervalEnd, setIntervalEnd] = useState4(data.intervalEnd);
+  const incoming = useIncomingComputedData7(id);
+  const updateNodeData = useUpdateNodeData5();
+  const updateComputedData = useUpdateNodeComputedData7();
+  useEffect7(() => {
+    if (incoming?.length) {
+      const source = incoming[0].module;
+      const module = new NormalizeNoiseModule(source, intervalStart, intervalEnd);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { intervalStart, intervalEnd });
+  }, [incoming, intervalStart, intervalEnd]);
+  return /* @__PURE__ */ jsxs5(NodeContainer7, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx7(Stack3, { children: /* @__PURE__ */ jsxs5(Group4, { children: [
+      /* @__PURE__ */ jsx7(
+        NumberInput4,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalStart,
+          onChange: (e) => setIntervalStart(Number(e))
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        NumberInput4,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalEnd,
+          onChange: (e) => setIntervalEnd(Number(e))
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx7(NodeTrackConnections7, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_normalize_node_default = NoiseNormalizeNode;
+
+// src/nodes/modifiers/noise-scale-bias-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData8,
+  useUpdateNodeComputedData as useUpdateNodeComputedData8,
+  useUpdateNodeData as useUpdateNodeData6
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer8, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
+import { Group as Group5, NumberInput as NumberInput5, Stack as Stack4 } from "@mantine/core";
+import { ScaleBias } from "libnoise-simplex-ts";
+import { useEffect as useEffect8, useState as useState5 } from "react";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function NoiseScaleBiasNode({ id, selected, data, type }) {
+  const [scale, setScale] = useState5(data.scale);
+  const [bias, setBias] = useState5(data.bias);
+  const incoming = useIncomingComputedData8(id);
+  const updateNodeData = useUpdateNodeData6();
+  const updateComputedData = useUpdateNodeComputedData8();
+  useEffect8(() => {
+    if (incoming?.length > 0) {
+      const module = new ScaleBias(incoming[0].module, scale, bias);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { scale, bias });
+  }, [incoming, scale, bias]);
+  return /* @__PURE__ */ jsxs6(NodeContainer8, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs6(Stack4, { children: [
+      /* @__PURE__ */ jsxs6(Group5, { children: [
+        "Scale:",
+        /* @__PURE__ */ jsx8(
+          NumberInput5,
+          {
+            size: "xs",
+            w: 100,
+            value: scale,
+            onChange: (e) => setScale(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs6(Group5, { children: [
+        "Bias:",
+        /* @__PURE__ */ jsx8(
+          NumberInput5,
+          {
+            size: "xs",
+            w: 100,
+            value: bias,
+            onChange: (e) => setBias(Number(e)),
+            step: 0.1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx8(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_scale_bias_node_default = NoiseScaleBiasNode;
+
+// src/nodes/modifiers/noise-terrace-node.tsx
+import { NodeState as NodeState2 } from "@awesome-flow/core/abstract";
+import {
+  useIncomingComputedData as useIncomingComputedData9,
+  useUpdateNodeComputedData as useUpdateNodeComputedData9,
+  useUpdateNodeData as useUpdateNodeData7
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer9, NodeTrackConnections as NodeTrackConnections9 } from "@awesome-flow/core/layout";
+import { ActionIcon as ActionIcon2, Button as Button2, Group as Group6, NumberInput as NumberInput6, Space as Space2 } from "@mantine/core";
+import { FORM_INDEX as FORM_INDEX2, useForm as useForm2 } from "@mantine/form";
+import { randomId as randomId2 } from "@mantine/hooks";
+import { IconX as IconX2 } from "@tabler/icons-react";
+import { Terrace } from "libnoise-simplex-ts";
+import { useCallback as useCallback3, useEffect as useEffect9, useState as useState6 } from "react";
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function NoiseTerraceNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData9(id);
+  const updateNodeData = useUpdateNodeData7();
+  const updateComputedData = useUpdateNodeComputedData9();
+  const [values, setValues] = useState6([]);
+  const form = useForm2({
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${FORM_INDEX2}.input`],
+    clearInputErrorOnChange: true,
+    onValuesChange: useCallback3((values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => v.value);
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  useEffect9(() => {
+    const points = data.points?.length ? data.points.map((v) => ({ value: v, key: randomId2() })) : [1, 2].map(() => ({ value: 0, key: randomId2() }));
+    form.initialize({ points });
+  }, []);
+  useEffect9(() => {
+    if (incoming?.length && values?.length >= 2) {
+      const module = new Terrace(incoming[0].module, values);
+      updateComputedData(id, { module });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs7(Group6, { mt: "xs", children: [
+    /* @__PURE__ */ jsx9(
+      NumberInput6,
+      {
+        size: "xs",
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.value`),
+        step: 0.1
+      },
+      form.key(`points.${index}.value`)
+    ),
+    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx9(
+      ActionIcon2,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ jsx9(IconX2, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ jsxs7(NodeContainer9, { id, selected, type, data, children: [
+    fields,
+    data.state === NodeState2.edit && /* @__PURE__ */ jsxs7(Fragment2, { children: [
+      /* @__PURE__ */ jsx9(Space2, { h: 10 }),
+      /* @__PURE__ */ jsx9(
+        Button2,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { value: 0, key: randomId2() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx9(NodeTrackConnections9, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_terrace_node_default = NoiseTerraceNode;
+
+export {
+  noise_abs_node_default,
+  noise_clamp_node_default,
+  NoiseCombineType,
+  noiseCombineModuleMap,
+  noise_combine_node_default,
+  noise_curve_node_default,
+  noise_exponent_node_default,
+  noise_invert_node_default,
+  noise_normalize_node_default,
+  noise_scale_bias_node_default,
+  noise_terrace_node_default
+};