origam 0.1.0

package/dist/src/utils/DataTable/headers.util.js

@@ -0,0 +1,160 @@
+import { DEFAULT_ACTION_HEADER, DEFAULT_HEADER } from "@foxy/consts";
+import { consoleError } from "@foxy/utils";
+export function extractKeys(headers, keys = /* @__PURE__ */ new Set()) {
+  for (const item of headers) {
+    if (item.key) keys.add(item.key);
+    if (item.children) {
+      extractKeys(item.children, keys);
+    }
+  }
+  return keys;
+}
+export function getDataTableHeadersDefaultItem(item) {
+  if (!item.key) return void 0;
+  if (item.key === "data-table-group") return DEFAULT_HEADER;
+  if (["data-table-expand", "data-table-select"].includes(item.key)) return DEFAULT_ACTION_HEADER;
+  return void 0;
+}
+export function convertToInternalHeaders(items) {
+  const internalHeaders = [];
+  for (const item of items) {
+    const defaultItem = { ...getDataTableHeadersDefaultItem(item), ...item };
+    const key = defaultItem.key ?? (typeof defaultItem.value === "string" ? defaultItem.value : null);
+    const value = defaultItem.value ?? key ?? null;
+    const internalItem = {
+      ...defaultItem,
+      key,
+      value,
+      sortable: defaultItem.sortable ?? (defaultItem.key != null || !!defaultItem.sort),
+      children: defaultItem.children ? convertToInternalHeaders(defaultItem.children) : void 0
+    };
+    internalHeaders.push(internalItem);
+  }
+  return internalHeaders;
+}
+export function parseFixedColumns(items) {
+  let seenFixed = false;
+  const setFixed = (item, parentFixed = false) => {
+    if (!item) return;
+    if (parentFixed) {
+      item.fixed = true;
+    }
+    if (item.fixed) {
+      if (item.children) {
+        for (let i = item.children.length - 1; i >= 0; i--) {
+          setFixed(item.children[i], true);
+        }
+      } else {
+        if (!seenFixed) {
+          item.lastFixed = true;
+        } else if (isNaN(+item.width)) {
+          consoleError(`Multiple fixed columns should have a static width (key: ${item.key})`);
+        }
+        seenFixed = true;
+      }
+    } else {
+      if (item.children) {
+        for (let i = item.children.length - 1; i >= 0; i--) {
+          setFixed(item.children[i]);
+        }
+      } else {
+        seenFixed = false;
+      }
+    }
+  };
+  const setFixedOffset = (item, fixedOffset2 = 0) => {
+    if (!item) return fixedOffset2;
+    if (item.children) {
+      item.fixedOffset = fixedOffset2;
+      for (const child of item.children) {
+        fixedOffset2 = setFixedOffset(child, fixedOffset2);
+      }
+    } else if (item.fixed) {
+      item.fixedOffset = fixedOffset2;
+      fixedOffset2 += parseFloat(item.width || "0") || 0;
+    }
+    return fixedOffset2;
+  };
+  let fixedOffset = 0;
+  for (let i = items.length - 1; i >= 0; i--) {
+    setFixed(items[i]);
+  }
+  for (const item of items) {
+    fixedOffset = setFixedOffset(item, fixedOffset);
+  }
+}
+export function parseHeaderItems(items, maxDepth) {
+  const headers = [];
+  let currentDepth = 0;
+  const queue = priorityQueue(items);
+  while (queue.size() > 0) {
+    let rowSize = queue.count();
+    let fraction = 1;
+    const row = [];
+    while (rowSize > 0) {
+      const { element: item, priority } = queue.dequeue();
+      const diff = maxDepth - currentDepth - getHeaderDepth(item);
+      row.push({
+        ...item,
+        rowspan: diff ?? 1,
+        colspan: item.children ? extractLeaves(item).length : 1
+      });
+      if (item.children) {
+        for (const child of item.children) {
+          const sort = priority % 1 + fraction / Math.pow(10, currentDepth + 2);
+          queue.enqueue(child, currentDepth + diff + sort);
+        }
+      }
+      fraction += 1;
+      rowSize -= 1;
+    }
+    currentDepth += 1;
+    headers.push(row);
+  }
+  const columns = items.map((item) => extractLeaves(item)).flat();
+  return { columns, headers };
+}
+export function getHeaderDepth(item, depth = 0) {
+  if (!item.children) return depth;
+  return Math.max(depth, ...item.children.map((child) => getHeaderDepth(child, depth + 1)));
+}
+export function extractLeaves(item, columns = []) {
+  if (!item.children) {
+    columns.push(item);
+  } else {
+    for (const child of item.children) {
+      extractLeaves(child, columns);
+    }
+  }
+  return columns;
+}
+export function priorityQueue(arr = []) {
+  const queue = arr.map((element) => ({ element, priority: 0 }));
+  return {
+    enqueue: (element, priority) => {
+      let added = false;
+      for (let i = 0; i < queue.length; i++) {
+        const item = queue[i];
+        if (item.priority > priority) {
+          queue.splice(i, 0, { element, priority });
+          added = true;
+          break;
+        }
+      }
+      if (!added) queue.push({ element, priority });
+    },
+    size: () => queue.length,
+    count: () => {
+      let count = 0;
+      if (!queue.length) return 0;
+      const whole = Math.floor(queue[0].priority);
+      for (let i = 0; i < queue.length; i++) {
+        if (Math.floor(queue[i].priority) === whole) count += 1;
+      }
+      return count;
+    },
+    dequeue: () => {
+      return queue.shift();
+    }
+  };
+}

package/dist/src/utils/DataTable/items.util.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformDataTableItem = transformDataTableItem;
+exports.transformDataTableItems = transformDataTableItems;
+var _utils = require("@foxy/utils");
+function transformDataTableItems(props, items, columns) {
+  return items?.map((item, index) => transformDataTableItem(props, item, index, columns)) || [];
+}
+function transformDataTableItem(props, item, index, columns) {
+  const value = props.returnObject ? item : (0, _utils.getPropertyFromItem)(item, props.itemValue);
+  const selectable = (0, _utils.getPropertyFromItem)(item, props.itemSelectable, true);
+  const itemColumns = columns.reduce((obj, column) => {
+    if (column.key != null) obj[column.key] = (0, _utils.getPropertyFromItem)(item, column.value);
+    return obj;
+  }, {});
+  return {
+    type: "item",
+    key: props.returnObject ? (0, _utils.getPropertyFromItem)(item, props.itemValue) : value,
+    index,
+    value,
+    selectable,
+    columns: itemColumns,
+    raw: item
+  };
+}

package/dist/src/utils/DataTable/items.util.d.ts

@@ -0,0 +1,3 @@
+import type { IDataTableItem, IDataTableItemsProps, IInternalDataTableHeader } from '@foxy/interfaces';
+export declare function transformDataTableItems(props: Omit<IDataTableItemsProps, 'items'>, items: Array<IDataTableItem> | undefined, columns: Array<IInternalDataTableHeader>): Array<IDataTableItem>;
+export declare function transformDataTableItem(props: Omit<IDataTableItemsProps, 'items'>, item: IDataTableItem, index: number, columns: Array<IInternalDataTableHeader>): IDataTableItem;

package/dist/src/utils/DataTable/items.util.js

@@ -0,0 +1,21 @@
+import { getPropertyFromItem } from "@foxy/utils";
+export function transformDataTableItems(props, items, columns) {
+  return items?.map((item, index) => transformDataTableItem(props, item, index, columns)) || [];
+}
+export function transformDataTableItem(props, item, index, columns) {
+  const value = props.returnObject ? item : getPropertyFromItem(item, props.itemValue);
+  const selectable = getPropertyFromItem(item, props.itemSelectable, true);
+  const itemColumns = columns.reduce((obj, column) => {
+    if (column.key != null) obj[column.key] = getPropertyFromItem(item, column.value);
+    return obj;
+  }, {});
+  return {
+    type: "item",
+    key: props.returnObject ? getPropertyFromItem(item, props.itemValue) : value,
+    index,
+    value,
+    selectable,
+    columns: itemColumns,
+    raw: item
+  };
+}

package/dist/src/utils/DataTable/sort.util.cjs

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortItems = sortItems;
+var _enums = require("@foxy/enums");
+var _utils = require("@foxy/utils");
+function sortItems(items, sortByItems, options) {
+  const transformedItems = items.map(item => [item, options?.transform ? options.transform(item) : item]);
+  return transformedItems.sort((a, b) => {
+    for (let i = 0; i < sortByItems.length; i++) {
+      let hasCustomResult = false;
+      const sortKey = sortByItems[i].key;
+      const sortOrder = sortByItems[i].order ?? _enums.SORT_DIRECTION.ASC;
+      if (sortOrder === false) continue;
+      let sortA = a[1][sortKey];
+      let sortB = b[1][sortKey];
+      let sortARaw = a[0].raw;
+      let sortBRaw = b[0].raw;
+      if (sortOrder === _enums.SORT_DIRECTION.DESC) {
+        const tempA = sortA;
+        const tempB = sortB;
+        sortA = tempB;
+        sortB = tempA;
+        const tempARaw = sortARaw;
+        const tempBRaw = sortBRaw;
+        sortARaw = tempBRaw;
+        sortBRaw = tempARaw;
+      }
+      if (options?.sortRawFunctions?.[sortKey]) {
+        const customResult = options.sortRawFunctions[sortKey](sortARaw, sortBRaw);
+        if (customResult == null) continue;
+        hasCustomResult = true;
+        if (customResult) return customResult;
+      }
+      if (options?.sortFunctions?.[sortKey]) {
+        const customResult = options.sortFunctions[sortKey](sortA, sortB);
+        if (customResult == null) continue;
+        hasCustomResult = true;
+        if (customResult) return customResult;
+      }
+      if (hasCustomResult) continue;
+      if (sortA instanceof Date && sortB instanceof Date) {
+        return sortA.getTime() - sortB.getTime();
+      }
+      sortA = sortA != null ? sortA.toString().toLocaleLowerCase() : sortA;
+      sortB = sortB != null ? sortB.toString().toLocaleLowerCase() : sortB;
+      if (sortA !== sortB) {
+        if ((0, _utils.isEmpty)(sortA) && (0, _utils.isEmpty)(sortB)) return 0;
+        if ((0, _utils.isEmpty)(sortA)) return -1;
+        if ((0, _utils.isEmpty)(sortB)) return 1;
+        if (!isNaN(sortA) && !isNaN(sortB)) return Number(sortA) - Number(sortB);
+        return sortA.localeCompare(sortB);
+      }
+    }
+    return 0;
+  }).map(([item]) => item);
+}

package/dist/src/utils/DataTable/sort.util.d.ts

@@ -0,0 +1,7 @@
+import type { IDataTableSortItem, IInternalItem } from '@foxy/interfaces';
+import type { TDataTableCompareFunction } from '@foxy/types';
+export declare function sortItems<T extends IInternalItem>(items: T[], sortByItems: Array<IDataTableSortItem>, options?: {
+    transform?: (item: T) => Record<string, any>;
+    sortFunctions?: Record<string, TDataTableCompareFunction>;
+    sortRawFunctions?: Record<string, TDataTableCompareFunction>;
+}): T[];

package/dist/src/utils/DataTable/sort.util.js

@@ -0,0 +1,55 @@
+import { SORT_DIRECTION } from "@foxy/enums";
+import { isEmpty } from "@foxy/utils";
+export function sortItems(items, sortByItems, options) {
+  const transformedItems = items.map(
+    (item) => [item, options?.transform ? options.transform(item) : item]
+  );
+  return transformedItems.sort((a, b) => {
+    for (let i = 0; i < sortByItems.length; i++) {
+      let hasCustomResult = false;
+      const sortKey = sortByItems[i].key;
+      const sortOrder = sortByItems[i].order ?? SORT_DIRECTION.ASC;
+      if (sortOrder === false) continue;
+      let sortA = a[1][sortKey];
+      let sortB = b[1][sortKey];
+      let sortARaw = a[0].raw;
+      let sortBRaw = b[0].raw;
+      if (sortOrder === SORT_DIRECTION.DESC) {
+        const tempA = sortA;
+        const tempB = sortB;
+        sortA = tempB;
+        sortB = tempA;
+        const tempARaw = sortARaw;
+        const tempBRaw = sortBRaw;
+        sortARaw = tempBRaw;
+        sortBRaw = tempARaw;
+      }
+      if (options?.sortRawFunctions?.[sortKey]) {
+        const customResult = options.sortRawFunctions[sortKey](sortARaw, sortBRaw);
+        if (customResult == null) continue;
+        hasCustomResult = true;
+        if (customResult) return customResult;
+      }
+      if (options?.sortFunctions?.[sortKey]) {
+        const customResult = options.sortFunctions[sortKey](sortA, sortB);
+        if (customResult == null) continue;
+        hasCustomResult = true;
+        if (customResult) return customResult;
+      }
+      if (hasCustomResult) continue;
+      if (sortA instanceof Date && sortB instanceof Date) {
+        return sortA.getTime() - sortB.getTime();
+      }
+      sortA = sortA != null ? sortA.toString().toLocaleLowerCase() : sortA;
+      sortB = sortB != null ? sortB.toString().toLocaleLowerCase() : sortB;
+      if (sortA !== sortB) {
+        if (isEmpty(sortA) && isEmpty(sortB)) return 0;
+        if (isEmpty(sortA)) return -1;
+        if (isEmpty(sortB)) return 1;
+        if (!isNaN(sortA) && !isNaN(sortB)) return Number(sortA) - Number(sortB);
+        return sortA.localeCompare(sortB);
+      }
+    }
+    return 0;
+  }).map(([item]) => item);
+}

package/dist/src/utils/Input/input.util.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterInputAttrs = filterInputAttrs;
+var _consts = require("@foxy/consts");
+var _utils = require("@foxy/utils");
+function filterInputAttrs(attrs) {
+  const [events, props] = (0, _utils.pickWithRest)(attrs, [_consts.ON_REGEX]);
+  const inputEvents = (0, _utils.omit)(events, _consts.BUBBLING_EVENTS);
+  const [rootAttrs, inputAttrs] = (0, _utils.pickWithRest)(props, ["class", "style", "id", /^data-/]);
+  Object.assign(rootAttrs, events);
+  Object.assign(inputAttrs, inputEvents);
+  return [rootAttrs, inputAttrs];
+}

package/dist/src/utils/Input/input.util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filter attributes that should be applied to
+ * the root element of an input component. Remaining
+ * attributes should be passed to the <input> element inside.
+ */
+export declare function filterInputAttrs(attrs: Record<string, unknown>): any[];

package/dist/src/utils/Input/input.util.js

@@ -0,0 +1,10 @@
+import { BUBBLING_EVENTS, ON_REGEX } from "@foxy/consts";
+import { omit, pickWithRest } from "@foxy/utils";
+export function filterInputAttrs(attrs) {
+  const [events, props] = pickWithRest(attrs, [ON_REGEX]);
+  const inputEvents = omit(events, BUBBLING_EVENTS);
+  const [rootAttrs, inputAttrs] = pickWithRest(props, ["class", "style", "id", /^data-/]);
+  Object.assign(rootAttrs, events);
+  Object.assign(inputAttrs, inputEvents);
+  return [rootAttrs, inputAttrs];
+}

package/dist/src/utils/List/list-item.util.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformListItem = transformListItem;
+exports.transformListItems = transformListItems;
+var _utils = require("@foxy/utils");
+function transformListItems(props, items) {
+  const array = [];
+  for (const item of items) {
+    array.push(transformListItem(props, item));
+  }
+  return array;
+}
+function transformListItem(props, item) {
+  const title = (0, _utils.getPropertyFromItem)(item, props.itemTitle, item);
+  const value = (0, _utils.getPropertyFromItem)(item, props.itemValue, title);
+  const children = (0, _utils.getPropertyFromItem)(item, props.itemChildren);
+  const itemProps = props.itemProps === true ? typeof item === "object" && item != null && !Array.isArray(item) ? "children" in item ? (0, _utils.omit)(item, ["children"]) : item : void 0 : (0, _utils.getPropertyFromItem)(item, props.itemProps);
+  const _props = {
+    title,
+    value,
+    ...itemProps
+  };
+  return {
+    title: String(_props.title ?? ""),
+    value: _props.value,
+    props: _props,
+    children: Array.isArray(children) ? transformListItems(props, children) : void 0,
+    raw: item
+  };
+}

package/dist/src/utils/List/list-item.util.d.ts

@@ -0,0 +1,5 @@
+import type { IInternalListItem, IItemProps } from '@foxy/interfaces';
+export declare function transformListItems(props: IItemProps & {
+    itemType?: string;
+}, items: Array<(string | object)>): IInternalListItemChildren[];
+export declare function transformListItem(props: Omit<IItemProps, 'items'>, item: any): IInternalListItem;

package/dist/src/utils/List/list-item.util.js

@@ -0,0 +1,26 @@
+import { getPropertyFromItem, omit } from "@foxy/utils";
+export function transformListItems(props, items) {
+  const array = [];
+  for (const item of items) {
+    array.push(transformListItem(props, item));
+  }
+  return array;
+}
+export function transformListItem(props, item) {
+  const title = getPropertyFromItem(item, props.itemTitle, item);
+  const value = getPropertyFromItem(item, props.itemValue, title);
+  const children = getPropertyFromItem(item, props.itemChildren);
+  const itemProps = props.itemProps === true ? typeof item === "object" && item != null && !Array.isArray(item) ? "children" in item ? omit(item, ["children"]) : item : void 0 : getPropertyFromItem(item, props.itemProps);
+  const _props = {
+    title,
+    value,
+    ...itemProps
+  };
+  return {
+    title: String(_props.title ?? ""),
+    value: _props.value,
+    props: _props,
+    children: Array.isArray(children) ? transformListItems(props, children) : void 0,
+    raw: item
+  };
+}

package/dist/src/utils/PageBuilder/editor.util.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNameFromFile = getNameFromFile;
+exports.getTagName = getTagName;
+exports.scanForAutoProps = scanForAutoProps;
+var _changeCase = require("change-case");
+function getNameFromFile(file) {
+  const parts = /([^/]+)\.vue$/.exec(file);
+  if (parts) {
+    return (0, _changeCase.pascalCase)(parts[1]);
+  }
+  return "Anonymous";
+}
+function getTagName(vnode) {
+  if (typeof vnode.type === "string") {
+    return vnode.type;
+  } else if (vnode.type?.__asyncResolved) {
+    const asyncComp = vnode.type?.__asyncResolved;
+    return asyncComp.name ?? getNameFromFile(asyncComp.__file);
+  } else if (vnode.type?.name) {
+    return vnode.type.name;
+  } else if (vnode.type?.__file) {
+    return getNameFromFile(vnode.type.__file);
+  }
+  return "Anonymous";
+}
+function scanForAutoProps(vnodes) {
+  const result = [];
+  let index = 0;
+  for (const vnode of vnodes) {
+    if (typeof vnode.type === "object") {
+      const propDefs = [];
+      for (const key in vnode.type.props) {
+        const prop = vnode.type.props[key];
+        let types;
+        let defaultValue;
+        if (prop) {
+          const rawTypes = Array.isArray(prop.type) ? prop.type : typeof prop === "function" ? [prop] : [prop.type];
+          types = rawTypes.map(t => {
+            switch (t) {
+              case String:
+                return "string";
+              case Number:
+                return "number";
+              case Boolean:
+                return "boolean";
+              case Object:
+                return "object";
+              case Array:
+                return "array";
+              default:
+                return "unknown";
+            }
+          });
+          defaultValue = typeof prop.default === "function" ? prop.default.toString() : prop.default;
+        }
+        propDefs.push({
+          name: key,
+          types,
+          required: prop?.required,
+          default: defaultValue
+        });
+      }
+      result.push({
+        name: getTagName(vnode),
+        index,
+        props: propDefs
+      });
+      index++;
+    }
+    if (Array.isArray(vnode.children)) {
+      result.push(...scanForAutoProps(vnode.children));
+    }
+  }
+  return result.filter(def => def.props.length);
+}

package/dist/src/utils/PageBuilder/editor.util.d.ts

@@ -0,0 +1,4 @@
+import { VNode } from 'vue';
+export declare function getNameFromFile(file: string): string;
+export declare function getTagName(vnode: VNode): any;
+export declare function scanForAutoProps(vnodes: Array<any>): any[];

package/dist/src/utils/PageBuilder/editor.util.js

@@ -0,0 +1,71 @@
+import { pascalCase } from "change-case";
+export function getNameFromFile(file) {
+  const parts = /([^/]+)\.vue$/.exec(file);
+  if (parts) {
+    return pascalCase(parts[1]);
+  }
+  return "Anonymous";
+}
+export function getTagName(vnode) {
+  if (typeof vnode.type === "string") {
+    return vnode.type;
+  } else if (vnode.type?.__asyncResolved) {
+    const asyncComp = vnode.type?.__asyncResolved;
+    return asyncComp.name ?? getNameFromFile(asyncComp.__file);
+  } else if (vnode.type?.name) {
+    return vnode.type.name;
+  } else if (vnode.type?.__file) {
+    return getNameFromFile(vnode.type.__file);
+  }
+  return "Anonymous";
+}
+export function scanForAutoProps(vnodes) {
+  const result = [];
+  let index = 0;
+  for (const vnode of vnodes) {
+    if (typeof vnode.type === "object") {
+      const propDefs = [];
+      for (const key in vnode.type.props) {
+        const prop = vnode.type.props[key];
+        let types;
+        let defaultValue;
+        if (prop) {
+          const rawTypes = Array.isArray(prop.type) ? prop.type : typeof prop === "function" ? [prop] : [prop.type];
+          types = rawTypes.map((t) => {
+            switch (t) {
+              case String:
+                return "string";
+              case Number:
+                return "number";
+              case Boolean:
+                return "boolean";
+              case Object:
+                return "object";
+              case Array:
+                return "array";
+              default:
+                return "unknown";
+            }
+          });
+          defaultValue = typeof prop.default === "function" ? prop.default.toString() : prop.default;
+        }
+        propDefs.push({
+          name: key,
+          types,
+          required: prop?.required,
+          default: defaultValue
+        });
+      }
+      result.push({
+        name: getTagName(vnode),
+        index,
+        props: propDefs
+      });
+      index++;
+    }
+    if (Array.isArray(vnode.children)) {
+      result.push(...scanForAutoProps(vnode.children));
+    }
+  }
+  return result.filter((def) => def.props.length);
+}

package/dist/src/utils/Parallax/parallax-element.util.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cyclicMovement = cyclicMovement;
+exports.elementMovement = elementMovement;
+function elementMovement(action) {
+  const {
+    y,
+    x,
+    target,
+    strength = 10,
+    event = null,
+    minX,
+    minY,
+    maxX,
+    maxY
+  } = action;
+  const {
+    originX = 50
+  } = action;
+  let {
+    originY = 50
+  } = action;
+  if (event === "scroll") {
+    originY = -originY / 2;
+  }
+  let movementX = (x - originX / 50) * strength;
+  let movementY = (y - originY / 50) * strength;
+  if (minX || maxX) {
+    movementX = maxX && movementX > maxX ? maxX : minX && movementX < minX ? minX : movementX;
+  }
+  if (minY || maxY) {
+    movementY = maxY && movementY > maxY ? maxY : minY && movementY < minY ? minY : movementY;
+  }
+  return {
+    x: movementX,
+    y: movementY,
+    target
+  };
+}
+function cyclicMovement(cycleData) {
+  const {
+    referencePosition,
+    shape,
+    event,
+    cycles,
+    strength
+  } = cycleData;
+  const spanningRangeX = event === "scroll" ? window.innerWidth : shape?.width;
+  const spanningRangeY = event === "scroll" ? window.innerHeight : shape?.height;
+  const radialPositionX = (referencePosition.x - shape?.left) * (Math.PI * 2) / spanningRangeX;
+  const radialPositionY = (referencePosition.y - shape?.top) * (Math.PI * 2) / spanningRangeY;
+  const cycleX = spanningRangeX * Math.sin(radialPositionX * cycles);
+  const cycleY = spanningRangeY * Math.sin(radialPositionY * cycles);
+  return {
+    x: cycleX * strength / (spanningRangeX / 2),
+    y: cycleY * strength / (spanningRangeY / 2)
+  };
+}

package/dist/src/utils/Parallax/parallax-element.util.d.ts

@@ -0,0 +1,8 @@
+import type { IParallaxElementCicle, IParallaxElementMovement } from '@foxy/interfaces';
+import type { TPoint } from '@foxy/types';
+export declare function elementMovement(action: IParallaxElementMovement): {
+    x: number;
+    y: number;
+    target: IParallaxElementMovement;
+};
+export declare function cyclicMovement(cycleData: IParallaxElementCicle): TPoint;