@awesome-flow/noise 0.7.1 → 0.9.0

package/dist/chunk-KHIIB5TH.js

@@ -0,0 +1,93 @@
+// src/nodes/groups/module-group-node.tsx
+import {
+  useFlowStore,
+  useIncomingComputedData,
+  useInteractiveStore,
+  useUpdateNodeComputedData
+} from "@awesome-flow/core/hooks";
+import { NodeCollapse, NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
+import { Badge, Group } from "@mantine/core";
+import { NodeResizer, useStore, useUpdateNodeInternals } from "@xyflow/react";
+import { useCallback, useEffect, useMemo } from "react";
+import { shallow } from "zustand/shallow";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ModuleGroupNode({
+  id,
+  selected,
+  data,
+  type,
+  width,
+  height
+}) {
+  const updateNodeInternals = useUpdateNodeInternals();
+  const triggerNodeChanges = useStore((s) => s.triggerNodeChanges);
+  const { groupNodes, setGroupCollapsed } = useFlowStore(
+    useCallback(
+      (state) => ({ groupNodes: state.groups[id], setGroupCollapsed: state.setGroupCollapsed }),
+      []
+    )
+  );
+  const intersectingNode = useInteractiveStore(
+    useCallback((state) => state.nodeIntersectionTargets[id], [id]),
+    shallow
+  );
+  useEffect(() => {
+    updateNodeInternals(id);
+  }, [width, height]);
+  useEffect(() => {
+    triggerNodeChanges([
+      {
+        id,
+        type: "select",
+        selected: !!intersectingNode
+      }
+    ]);
+  }, [intersectingNode]);
+  const onCollapsed = useCallback((collapsed) => {
+    setGroupCollapsed(id, collapsed);
+  }, []);
+  const size = useMemo(() => {
+    return {
+      width: data.initialSize?.width || 100,
+      height: data.initialSize?.height || 50
+    };
+  }, [data.initialSize]);
+  const incomingModules = useIncomingComputedData(id);
+  const updateComputedData = useUpdateNodeComputedData();
+  useEffect(() => {
+    if (incomingModules?.length) {
+      const { module } = incomingModules[0];
+      updateComputedData(id, { module });
+    }
+  }, [incomingModules]);
+  return /* @__PURE__ */ jsxs(
+    NodeContainer,
+    {
+      id,
+      selected,
+      data,
+      title: /* @__PURE__ */ jsx(Group, { justify: "space-between", children: /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+        /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
+        /* @__PURE__ */ jsx(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
+      ] }) }),
+      type,
+      children: [
+        /* @__PURE__ */ jsx(
+          NodeResizer,
+          {
+            nodeId: id,
+            minWidth: size.width,
+            minHeight: size.height,
+            isVisible: selected && !data.isCollapsed
+          }
+        ),
+        /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+      ]
+    }
+  );
+}
+var module_group_node_default = ModuleGroupNode;
+
+export {
+  module_group_node_default
+};

package/dist/chunk-M67JHEU2.cjs

@@ -0,0 +1,93 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/nodes/groups/module-group-node.tsx
+
+
+
+
+
+var _hooks = require('@awesome-flow/core/hooks');
+var _layout = require('@awesome-flow/core/layout');
+var _core = require('@mantine/core');
+var _react = require('@xyflow/react');
+var _react3 = require('react');
+var _shallow = require('zustand/shallow');
+var _jsxruntime = require('react/jsx-runtime');
+function ModuleGroupNode({
+  id,
+  selected,
+  data,
+  type,
+  width,
+  height
+}) {
+  const updateNodeInternals = _react.useUpdateNodeInternals.call(void 0, );
+  const triggerNodeChanges = _react.useStore.call(void 0, (s) => s.triggerNodeChanges);
+  const { groupNodes, setGroupCollapsed } = _hooks.useFlowStore.call(void 0, 
+    _react3.useCallback.call(void 0, 
+      (state) => ({ groupNodes: state.groups[id], setGroupCollapsed: state.setGroupCollapsed }),
+      []
+    )
+  );
+  const intersectingNode = _hooks.useInteractiveStore.call(void 0, 
+    _react3.useCallback.call(void 0, (state) => state.nodeIntersectionTargets[id], [id]),
+    _shallow.shallow
+  );
+  _react3.useEffect.call(void 0, () => {
+    updateNodeInternals(id);
+  }, [width, height]);
+  _react3.useEffect.call(void 0, () => {
+    triggerNodeChanges([
+      {
+        id,
+        type: "select",
+        selected: !!intersectingNode
+      }
+    ]);
+  }, [intersectingNode]);
+  const onCollapsed = _react3.useCallback.call(void 0, (collapsed) => {
+    setGroupCollapsed(id, collapsed);
+  }, []);
+  const size = _react3.useMemo.call(void 0, () => {
+    return {
+      width: _optionalChain([data, 'access', _ => _.initialSize, 'optionalAccess', _2 => _2.width]) || 100,
+      height: _optionalChain([data, 'access', _3 => _3.initialSize, 'optionalAccess', _4 => _4.height]) || 50
+    };
+  }, [data.initialSize]);
+  const incomingModules = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react3.useEffect.call(void 0, () => {
+    if (_optionalChain([incomingModules, 'optionalAccess', _5 => _5.length])) {
+      const { module } = incomingModules[0];
+      updateComputedData(id, { module });
+    }
+  }, [incomingModules]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _layout.NodeContainer,
+    {
+      id,
+      selected,
+      data,
+      title: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Group, { justify: "space-between", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { gap: "xs", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: _optionalChain([groupNodes, 'optionalAccess', _6 => _6.length]) || 0 }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
+      ] }) }),
+      type,
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _react.NodeResizer,
+          {
+            nodeId: id,
+            minWidth: size.width,
+            minHeight: size.height,
+            isVisible: selected && !data.isCollapsed
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+      ]
+    }
+  );
+}
+var module_group_node_default = ModuleGroupNode;
+
+
+
+exports.module_group_node_default = module_group_node_default;

package/dist/chunk-N6YNJKLS.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-PS5VUND5.js

@@ -0,0 +1,348 @@
+// src/nodes/transformers/noise-displace-node.tsx
+import { HandlesIncomingDataStatus } from "@awesome-flow/core/components";
+import { useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
+import { NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
+import { Displace } from "libnoise-simplex-ts";
+import { useCallback } from "react";
+
+// src/abstract/handle-types.ts
+var NoiseHandleType = /* @__PURE__ */ ((NoiseHandleType2) => {
+  NoiseHandleType2["texture"] = "texture";
+  NoiseHandleType2["noise"] = "noise";
+  NoiseHandleType2["position"] = "position";
+  NoiseHandleType2["module"] = "module";
+  return NoiseHandleType2;
+})(NoiseHandleType || {});
+var DisplacementHandle = /* @__PURE__ */ ((DisplacementHandle2) => {
+  DisplacementHandle2["sourceModule"] = "source";
+  DisplacementHandle2["xModule"] = "x-module";
+  DisplacementHandle2["yModule"] = "y-module";
+  DisplacementHandle2["zModule"] = "z-module";
+  DisplacementHandle2["output"] = "output";
+  return DisplacementHandle2;
+})(DisplacementHandle || {});
+var NoiseSourceControlHandle = /* @__PURE__ */ ((NoiseSourceControlHandle2) => {
+  NoiseSourceControlHandle2["source"] = "source";
+  NoiseSourceControlHandle2["control"] = "control";
+  NoiseSourceControlHandle2["output"] = "output";
+  return NoiseSourceControlHandle2;
+})(NoiseSourceControlHandle || {});
+
+// src/nodes/transformers/noise-displace-node.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function NoiseDisplaceNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData();
+  const onDataUpdated = useCallback(
+    (handleData) => {
+      const sourceModule = handleData["source" /* sourceModule */];
+      const xModule = handleData["x-module" /* xModule */];
+      const yModule = handleData["y-module" /* yModule */];
+      const zModule = handleData["z-module" /* zModule */];
+      if (sourceModule && xModule && yModule && zModule) {
+        const module = new Displace(
+          sourceModule[0].module,
+          xModule[0].module,
+          yModule[0].module,
+          zModule[0].module
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs(NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx(
+      HandlesIncomingDataStatus,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataId",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_displace_node_default = NoiseDisplaceNode;
+
+// src/nodes/transformers/noise-rotate-point-node.tsx
+import {
+  useIncomingComputedData,
+  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 { RotatePoint } from "libnoise-simplex-ts";
+import { useEffect, useState } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function NoiseRotatePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [xAngle, setXAngle] = useState(data.xAngle);
+  const [yAngle, setYAngle] = useState(data.yAngle);
+  const [zAngle, setZAngle] = useState(data.zAngle);
+  const incoming = useIncomingComputedData(id);
+  const updateNodeData = useUpdateNodeData();
+  const updateComputedData = useUpdateNodeComputedData2();
+  useEffect(() => {
+    if (incoming?.length) {
+      const module = new RotatePoint(incoming[0].module, xAngle, yAngle, zAngle);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { xAngle, yAngle, zAngle });
+  }, [id, updateComputedData, updateNodeData, incoming, xAngle, yAngle, zAngle]);
+  return /* @__PURE__ */ jsxs2(NodeContainer2, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs2(Stack, { children: [
+      /* @__PURE__ */ jsxs2(Group, { children: [
+        "X Angle:",
+        /* @__PURE__ */ jsx2(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: xAngle,
+            onChange: (e) => setXAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2(Group, { children: [
+        "Y Angle:",
+        /* @__PURE__ */ jsx2(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: yAngle,
+            onChange: (e) => setYAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2(Group, { children: [
+        "Z Angle:",
+        /* @__PURE__ */ jsx2(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: zAngle,
+            onChange: (e) => setZAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_rotate_point_node_default = NoiseRotatePointNode;
+
+// src/nodes/transformers/noise-scale-point-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData2,
+  useUpdateNodeComputedData as useUpdateNodeComputedData3,
+  useUpdateNodeData as useUpdateNodeData2
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer3, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
+import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
+import { ScalePoint } from "libnoise-simplex-ts";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function NoiseScalePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [xScale, setXScale] = useState2(data.xScale);
+  const [yScale, setYScale] = useState2(data.yScale);
+  const [zScale, setZScale] = useState2(data.zScale);
+  const incoming = useIncomingComputedData2(id);
+  const updateNodeData = useUpdateNodeData2();
+  const updateComputedData = useUpdateNodeComputedData3();
+  useEffect2(() => {
+    if (incoming?.length) {
+      const module = new ScalePoint(incoming[0].module, xScale, yScale, zScale);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { xScale, yScale, zScale });
+  }, [id, incoming, updateComputedData, updateNodeData, xScale, yScale, zScale]);
+  return /* @__PURE__ */ jsxs3(NodeContainer3, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs3(Stack2, { children: [
+      /* @__PURE__ */ jsxs3(Group2, { children: [
+        "X Scale:",
+        /* @__PURE__ */ jsx3(
+          NumberInput2,
+          {
+            size: "xs",
+            w: 100,
+            value: xScale,
+            onChange: (e) => setXScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3(Group2, { children: [
+        "Y Scale:",
+        /* @__PURE__ */ jsx3(
+          NumberInput2,
+          {
+            size: "xs",
+            w: 100,
+            value: yScale,
+            onChange: (e) => setYScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3(Group2, { children: [
+        "Z Scale:",
+        /* @__PURE__ */ jsx3(
+          NumberInput2,
+          {
+            size: "xs",
+            w: 100,
+            value: zScale,
+            onChange: (e) => setZScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_scale_point_node_default = NoiseScalePointNode;
+
+// src/nodes/transformers/noise-translate-point-node.tsx
+import {
+  useIncomingComputedData as useIncomingComputedData3,
+  useUpdateNodeComputedData as useUpdateNodeComputedData4,
+  useUpdateNodeData as useUpdateNodeData3
+} from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer4, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
+import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
+import { TranslatePoint } from "libnoise-simplex-ts";
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function NoiseTranslatePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [translateX, setTranslateX] = useState3(data.translateX);
+  const [translateY, setTranslateY] = useState3(data.translateY);
+  const [translateZ, setTranslateZ] = useState3(data.translateZ);
+  const incoming = useIncomingComputedData3(id);
+  const updateNodeData = useUpdateNodeData3();
+  const updateComputedData = useUpdateNodeComputedData4();
+  useEffect3(() => {
+    if (incoming?.length) {
+      const module = new TranslatePoint(incoming[0].module, translateX, translateY, translateZ);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { translateX, translateY, translateZ });
+  }, [id, incoming, translateX, translateY, translateZ, updateComputedData, updateNodeData]);
+  return /* @__PURE__ */ jsxs4(NodeContainer4, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs4(Stack3, { children: [
+      /* @__PURE__ */ jsxs4(Group3, { children: [
+        "Translate X:",
+        /* @__PURE__ */ jsx4(
+          NumberInput3,
+          {
+            size: "xs",
+            w: 100,
+            value: translateX,
+            onChange: (e) => setTranslateX(Number(e)),
+            step: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4(Group3, { children: [
+        "Translate Y:",
+        /* @__PURE__ */ jsx4(
+          NumberInput3,
+          {
+            size: "xs",
+            w: 100,
+            value: translateY,
+            onChange: (e) => setTranslateY(Number(e)),
+            step: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4(Group3, { children: [
+        "Translate Z:",
+        /* @__PURE__ */ jsx4(
+          NumberInput3,
+          {
+            size: "xs",
+            w: 100,
+            value: translateZ,
+            onChange: (e) => setTranslateZ(Number(e)),
+            step: 1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_translate_point_node_default = NoiseTranslatePointNode;
+
+// src/nodes/transformers/noise-turbulence-node.tsx
+import { NodePropertyVariables } from "@awesome-flow/core/components";
+import { useIncomingComputedData as useIncomingComputedData4, useUpdateNodeComputedData as useUpdateNodeComputedData5 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
+import { Turbulence } from "libnoise-simplex-ts";
+import { useCallback as useCallback2, useEffect as useEffect4, useState as useState4 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function NoiseTurbulenceNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [properties, setProperties] = useState4(null);
+  const incoming = useIncomingComputedData4(id);
+  const updateComputedData = useUpdateNodeComputedData5();
+  const onPropertiesChange = useCallback2((props) => {
+    setProperties(props);
+  }, []);
+  useEffect4(() => {
+    if (incoming?.length && properties) {
+      const module = new Turbulence(
+        incoming[0].module,
+        properties.frequency.value,
+        properties.power.value,
+        properties.roughness.value,
+        properties.seed.value
+      );
+      updateComputedData(id, { module });
+    }
+  }, [id, incoming, properties]);
+  return /* @__PURE__ */ jsxs5(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx5(NodePropertyVariables, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_turbulence_node_default = NoiseTurbulenceNode;
+
+export {
+  NoiseHandleType,
+  DisplacementHandle,
+  NoiseSourceControlHandle,
+  noise_displace_node_default,
+  noise_rotate_point_node_default,
+  noise_scale_point_node_default,
+  noise_translate_point_node_default,
+  noise_turbulence_node_default
+};

package/dist/chunk-Q5FVGKKM.cjs

@@ -0,0 +1 @@
+"use strict";