@helpwave/hightide 0.0.13 → 0.0.15

package/dist/util/date.mjs

@@ -0,0 +1,156 @@
+// src/util/array.ts
+var equalSizeGroups = (array, groupSize) => {
+  if (groupSize <= 0) {
+    console.warn(`group size should be greater than 0: groupSize = ${groupSize}`);
+    return [[...array]];
+  }
+  const groups = [];
+  for (let i = 0; i < array.length; i += groupSize) {
+    groups.push(array.slice(i, Math.min(i + groupSize, array.length)));
+  }
+  return groups;
+};
+
+// src/util/date.ts
+var monthsList = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
+var weekDayList = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var formatDate = (date) => {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+};
+var formatDateTime = (date) => {
+  const dateString = formatDate(date);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${dateString}T${hours}:${minutes}`;
+};
+var getDaysInMonth = (year, month) => {
+  const lastDayOfMonth = new Date(year, month + 1, 0);
+  return lastDayOfMonth.getDate();
+};
+var changeDuration = (date, duration, isAdding) => {
+  const {
+    years = 0,
+    months = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+    milliseconds = 0
+  } = duration;
+  if (years < 0) {
+    console.error(`Range error years must be greater than 0: received ${years}`);
+    return new Date(date);
+  }
+  if (months < 0 || months > 11) {
+    console.error(`Range error month must be 0 <= month <= 11: received ${months}`);
+    return new Date(date);
+  }
+  if (days < 0) {
+    console.error(`Range error days must be greater than 0: received ${days}`);
+    return new Date(date);
+  }
+  if (hours < 0 || hours > 23) {
+    console.error(`Range error hours must be 0 <= hours <= 23: received ${hours}`);
+    return new Date(date);
+  }
+  if (minutes < 0 || minutes > 59) {
+    console.error(`Range error minutes must be 0 <= minutes <= 59: received ${minutes}`);
+    return new Date(date);
+  }
+  if (seconds < 0 || seconds > 59) {
+    console.error(`Range error seconds must be 0 <= seconds <= 59: received ${seconds}`);
+    return new Date(date);
+  }
+  if (milliseconds < 0) {
+    console.error(`Range error seconds must be greater than 0: received ${milliseconds}`);
+    return new Date(date);
+  }
+  const multiplier = isAdding ? 1 : -1;
+  const newDate = new Date(date);
+  newDate.setFullYear(newDate.getFullYear() + multiplier * years);
+  newDate.setMonth(newDate.getMonth() + multiplier * months);
+  newDate.setDate(newDate.getDate() + multiplier * days);
+  newDate.setHours(newDate.getHours() + multiplier * hours);
+  newDate.setMinutes(newDate.getMinutes() + multiplier * minutes);
+  newDate.setSeconds(newDate.getSeconds() + multiplier * seconds);
+  newDate.setMilliseconds(newDate.getMilliseconds() + multiplier * milliseconds);
+  return newDate;
+};
+var addDuration = (date, duration) => {
+  return changeDuration(date, duration, true);
+};
+var subtractDuration = (date, duration) => {
+  return changeDuration(date, duration, false);
+};
+var getBetweenDuration = (startDate, endDate) => {
+  const durationInMilliseconds = endDate.getTime() - startDate.getTime();
+  const millisecondsInSecond = 1e3;
+  const millisecondsInMinute = 60 * millisecondsInSecond;
+  const millisecondsInHour = 60 * millisecondsInMinute;
+  const millisecondsInDay = 24 * millisecondsInHour;
+  const millisecondsInMonth = 30 * millisecondsInDay;
+  const years = Math.floor(durationInMilliseconds / (365.25 * millisecondsInDay));
+  const months = Math.floor(durationInMilliseconds / millisecondsInMonth);
+  const days = Math.floor(durationInMilliseconds / millisecondsInDay);
+  const hours = Math.floor(durationInMilliseconds % millisecondsInDay / millisecondsInHour);
+  const seconds = Math.floor(durationInMilliseconds % millisecondsInHour / millisecondsInSecond);
+  const milliseconds = durationInMilliseconds % millisecondsInSecond;
+  return {
+    years,
+    months,
+    days,
+    hours,
+    seconds,
+    milliseconds
+  };
+};
+var isInTimeSpan = (value, startDate, endDate) => {
+  if (startDate && endDate) {
+    console.assert(startDate <= endDate);
+    return startDate <= value && value <= endDate;
+  } else if (startDate) {
+    return startDate <= value;
+  } else if (endDate) {
+    return endDate >= value;
+  } else {
+    return true;
+  }
+};
+var equalDate = (date1, date2) => {
+  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
+};
+var getWeeksForCalenderMonth = (date, weekStart, weeks = 6) => {
+  const month = date.getMonth();
+  const year = date.getFullYear();
+  const dayList = [];
+  let currentDate = new Date(year, month, 1);
+  const weekStartIndex = weekDayList.indexOf(weekStart);
+  while (currentDate.getDay() !== weekStartIndex) {
+    currentDate = subtractDuration(currentDate, { days: 1 });
+  }
+  while (dayList.length < 7 * weeks) {
+    const date2 = new Date(currentDate);
+    date2.setHours(date2.getHours(), date2.getMinutes());
+    dayList.push(date2);
+    currentDate = addDuration(currentDate, { days: 1 });
+  }
+  return equalSizeGroups(dayList, 7);
+};
+export {
+  addDuration,
+  changeDuration,
+  equalDate,
+  formatDate,
+  formatDateTime,
+  getBetweenDuration,
+  getDaysInMonth,
+  getWeeksForCalenderMonth,
+  isInTimeSpan,
+  monthsList,
+  subtractDuration,
+  weekDayList
+};
+//# sourceMappingURL=date.mjs.map

package/dist/util/date.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/array.ts","../../src/util/date.ts"],"sourcesContent":["export const equalSizeGroups = <T >(array: T[], groupSize: number): T[][] => {\n  if (groupSize <= 0) {\n    console.warn(`group size should be greater than 0: groupSize = ${groupSize}`)\n    return [[...array]]\n  }\n\n  const groups = []\n  for (let i = 0; i < array.length; i += groupSize) {\n    groups.push(array.slice(i, Math.min(i + groupSize, array.length)))\n  }\n  return groups\n}\n\n/**\n * @param start\n * @param end inclusive\n * @param allowEmptyRange Whether the range can be defined empty via end < start\n */\nexport const range = (start: number, end: number, allowEmptyRange: boolean = false): number[] => {\n  if (end < start) {\n    if (!allowEmptyRange) {\n      console.warn(`range: end (${end}) < start (${start}) should be allowed explicitly, set allowEmptyRange to true`)\n    }\n    return []\n  }\n  return Array.from({ length: end - start + 1 }, (_, index) => index + start)\n}\n\n/** Finds the closest match\n * @param list The list of all possible matches\n * @param firstCloser Return whether item1 is closer than item2\n */\nexport const closestMatch = <T >(list: T[], firstCloser: (item1: T, item2: T) => boolean) => {\n  return list.reduce((item1, item2) => {\n    return firstCloser(item1, item2) ? item1 : item2\n  })\n}\n\n/**\n * returns the item in middle of a list and its neighbours before and after\n * e.g. [1,2,3,4,5,6] for item = 1 would return [5,6,1,2,3]\n */\nexport const getNeighbours = <T >(list: T[], item: T, neighbourDistance: number = 2) => {\n  const index = list.indexOf(item)\n  const totalItems = neighbourDistance * 2 + 1\n  if (list.length < totalItems) {\n    console.warn('List is to short')\n    return list\n  }\n\n  if (index === -1) {\n    console.error('item not found in list')\n    return list.splice(0, totalItems)\n  }\n\n  let start = index - neighbourDistance\n  if (start < 0) {\n    start += list.length\n  }\n  const end = (index + neighbourDistance + 1) % list.length\n\n  const result: T[] = []\n  let ignoreOnce = list.length === totalItems\n  for (let i = start; i !== end || ignoreOnce; i = (i + 1) % list.length) {\n    result.push(list[i]!)\n    if (end === i && ignoreOnce) {\n      ignoreOnce = false\n    }\n  }\n  return result\n}\n\nexport const createLoopingListWithIndex = <T >(list: T[], startIndex: number = 0, length: number = 0, forwards: boolean = true) => {\n  if (length < 0) {\n    console.warn(`createLoopingList: length must be >= 0, given ${length}`)\n  } else if (length === 0) {\n    length = list.length\n  }\n\n  const returnList: [number, T][] = []\n\n  if (forwards) {\n    for (let i = startIndex; returnList.length < length; i = (i + 1) % list.length) {\n      returnList.push([i, list[i]!])\n    }\n  } else {\n    for (let i = startIndex; returnList.length < length; i = i === 0 ? i = list.length - 1 : i - 1) {\n      returnList.push([i, list[i]!])\n    }\n  }\n\n  return returnList\n}\n\nexport const createLoopingList = <T >(list: T[], startIndex: number = 0, length: number = 0, forwards: boolean = true) => {\n  return createLoopingListWithIndex(list, startIndex, length, forwards).map(([_, item]) => item)\n}\n\nexport const ArrayUtil = {\n  unique: <T>(list: T[]): T[] => {\n    const seen = new Set<T>()\n    return list.filter((item) => {\n      if (seen.has(item)) {\n        return false\n      }\n      seen.add(item)\n      return true\n    })\n  },\n\n  difference: <T>(list: T[], removeList: T[]): T[] => {\n    const remove = new Set<T>(removeList)\n    return list.filter((item) => !remove.has(item))\n  }\n}\n","import { equalSizeGroups } from './array'\n\nexport const monthsList = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'] as const\nexport type Month = typeof monthsList[number]\n\nexport const weekDayList = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'] as const\nexport type WeekDay = typeof weekDayList[number]\n\nexport const formatDate = (date: Date) => {\n  const year = date.getFullYear().toString().padStart(4, '0')\n  const month = (date.getMonth() + 1).toString().padStart(2, '0')\n  const day = (date.getDate()).toString().padStart(2, '0')\n  return `${year}-${month}-${day}`\n}\n\nexport const formatDateTime = (date: Date) => {\n  const dateString = formatDate(date)\n  const hours = date.getHours().toString().padStart(2, '0')\n  const minutes = date.getMinutes().toString().padStart(2, '0')\n  return `${dateString}T${hours}:${minutes}`\n}\n\nexport const getDaysInMonth = (year: number, month: number): number => {\n  const lastDayOfMonth = new Date(year, month + 1, 0)\n  return lastDayOfMonth.getDate()\n}\n\nexport type Duration = {\n  years?: number,\n  months?: number,\n  days?: number,\n  hours?: number,\n  minutes?: number,\n  seconds?: number,\n  milliseconds?: number,\n}\n\nexport const changeDuration = (date: Date, duration: Duration, isAdding?: boolean): Date => {\n  const {\n    years = 0,\n    months = 0,\n    days = 0,\n    hours = 0,\n    minutes = 0,\n    seconds = 0,\n    milliseconds = 0,\n  } = duration\n\n  // Check ranges\n  if (years < 0) {\n    console.error(`Range error years must be greater than 0: received ${years}`)\n    return new Date(date)\n  }\n  if (months < 0 || months > 11) {\n    console.error(`Range error month must be 0 <= month <= 11: received ${months}`)\n    return new Date(date)\n  }\n  if (days < 0) {\n    console.error(`Range error days must be greater than 0: received ${days}`)\n    return new Date(date)\n  }\n  if (hours < 0 || hours > 23) {\n    console.error(`Range error hours must be 0 <= hours <= 23: received ${hours}`)\n    return new Date(date)\n  }\n  if (minutes < 0 || minutes > 59) {\n    console.error(`Range error minutes must be 0 <= minutes <= 59: received ${minutes}`)\n    return new Date(date)\n  }\n  if (seconds < 0 || seconds > 59) {\n    console.error(`Range error seconds must be 0 <= seconds <= 59: received ${seconds}`)\n    return new Date(date)\n  }\n  if (milliseconds < 0) {\n    console.error(`Range error seconds must be greater than 0: received ${milliseconds}`)\n    return new Date(date)\n  }\n\n  const multiplier = isAdding ? 1 : -1\n\n  const newDate = new Date(date)\n\n  newDate.setFullYear(newDate.getFullYear() + multiplier * years)\n\n  newDate.setMonth(newDate.getMonth() + multiplier * months)\n\n  newDate.setDate(newDate.getDate() + multiplier * days)\n\n  newDate.setHours(newDate.getHours() + multiplier * hours)\n\n  newDate.setMinutes(newDate.getMinutes() + multiplier * minutes)\n\n  newDate.setSeconds(newDate.getSeconds() + multiplier * seconds)\n\n  newDate.setMilliseconds(newDate.getMilliseconds() + multiplier * milliseconds)\n\n  return newDate\n}\n\nexport const addDuration = (date: Date, duration: Duration): Date => {\n  return changeDuration(date, duration, true)\n}\n\nexport const subtractDuration = (date: Date, duration: Duration): Date => {\n  return changeDuration(date, duration, false)\n}\n\nexport const getBetweenDuration = (startDate: Date, endDate: Date): Duration => {\n  const durationInMilliseconds = endDate.getTime() - startDate.getTime()\n\n  const millisecondsInSecond = 1000\n  const millisecondsInMinute = 60 * millisecondsInSecond\n  const millisecondsInHour = 60 * millisecondsInMinute\n  const millisecondsInDay = 24 * millisecondsInHour\n  const millisecondsInMonth = 30 * millisecondsInDay // Rough estimation, can be adjusted\n\n  const years = Math.floor(durationInMilliseconds / (365.25 * millisecondsInDay))\n  const months = Math.floor(durationInMilliseconds / millisecondsInMonth)\n  const days = Math.floor(durationInMilliseconds / millisecondsInDay)\n  const hours = Math.floor((durationInMilliseconds % millisecondsInDay) / millisecondsInHour)\n  const seconds = Math.floor((durationInMilliseconds % millisecondsInHour) / millisecondsInSecond)\n  const milliseconds = durationInMilliseconds % millisecondsInSecond\n\n  return {\n    years,\n    months,\n    days,\n    hours,\n    seconds,\n    milliseconds,\n  }\n}\n\n/** Checks if a given date is in the range of two dates\n *\n * An undefined value for startDate or endDate means no bound for the start or end respectively\n */\nexport const isInTimeSpan = (value: Date, startDate?: Date, endDate?: Date): boolean => {\n  if(startDate && endDate) {\n    console.assert(startDate <= endDate)\n    return startDate <= value && value <= endDate\n  } else if (startDate) {\n    return startDate <= value\n  } else if(endDate) {\n    return endDate >= value\n  } else {\n    return true\n  }\n}\n\n/** Compare two dates on the year, month, day */\nexport const equalDate = (date1: Date, date2: Date) => {\n  return date1.getFullYear() === date2.getFullYear()\n    && date1.getMonth() === date2.getMonth()\n    && date1.getDate() === date2.getDate()\n}\n\nexport const getWeeksForCalenderMonth = (date: Date, weekStart: WeekDay, weeks: number = 6) => {\n  const month = date.getMonth()\n  const year = date.getFullYear()\n\n  const dayList: Date[] = []\n  let currentDate = new Date(year, month, 1) // Start of month\n  const weekStartIndex = weekDayList.indexOf(weekStart)\n\n  // Move the current day to the week before\n  while (currentDate.getDay() !== weekStartIndex) {\n    currentDate = subtractDuration(currentDate, { days: 1 })\n  }\n\n  while (dayList.length < 7 * weeks) {\n    const date = new Date(currentDate)\n    date.setHours(date.getHours(), date.getMinutes()) // To make sure we are not overwriting the time\n    dayList.push(date)\n    currentDate = addDuration(currentDate, { days: 1 })\n  }\n\n  // weeks\n  return equalSizeGroups(dayList, 7)\n}\n"],"mappings":"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","names":["date"]}

package/dist/util/easeFunctions.d.mts

@@ -0,0 +1,11 @@
+type EaseFunction = (t: number) => number;
+declare class EaseFunctions {
+    static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): {
+        x: EaseFunction;
+        y: EaseFunction;
+    };
+    static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction;
+    static easeInEaseOut(t: number): number;
+}
+
+export { type EaseFunction, EaseFunctions };

package/dist/util/easeFunctions.d.ts

@@ -1,5 +1,5 @@
-export type EaseFunction = (t: number) => number;
-export declare class EaseFunctions {
+type EaseFunction = (t: number) => number;
+declare class EaseFunctions {
     static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): {
         x: EaseFunction;
         y: EaseFunction;
@@ -7,3 +7,5 @@ export declare class EaseFunctions {
     static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction;
     static easeInEaseOut(t: number): number;
 }
+
+export { type EaseFunction, EaseFunctions };

package/dist/util/easeFunctions.js

@@ -1,30 +1,63 @@
-import { clamp } from './math';
-export class EaseFunctions {
-    static cubicBezierGeneric(x1, y1, x2, y2) {
-        // Calculate the x and y coordinates using the cubic Bézier formula
-        const cx = 3 * x1;
-        const bx = 3 * (x2 - x1) - cx;
-        const ax = 1 - cx - bx;
-        const cy = 3 * y1;
-        const by = 3 * (y2 - y1) - cy;
-        const ay = 1 - cy - by;
-        // Compute x and y values at parameter t
-        const x = (t) => ((ax * t + bx) * t + cx) * t;
-        const y = (t) => ((ay * t + by) * t + cy) * t;
-        return {
-            x,
-            y
-        };
-    }
-    static cubicBezier(x1, y1, x2, y2) {
-        const { y } = EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2);
-        return (t) => {
-            t = clamp(t);
-            return y(t); // <= equal to x(t) * 0 + y(t) * 1
-        };
-    }
-    static easeInEaseOut(t) {
-        return EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t);
-    }
-    ;
-}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/easeFunctions.ts
+var easeFunctions_exports = {};
+__export(easeFunctions_exports, {
+  EaseFunctions: () => EaseFunctions
+});
+module.exports = __toCommonJS(easeFunctions_exports);
+
+// src/util/math.ts
+var clamp = (value, min = 0, max = 1) => {
+  return Math.min(Math.max(value, min), max);
+};
+
+// src/util/easeFunctions.ts
+var EaseFunctions = class _EaseFunctions {
+  static cubicBezierGeneric(x1, y1, x2, y2) {
+    const cx = 3 * x1;
+    const bx = 3 * (x2 - x1) - cx;
+    const ax = 1 - cx - bx;
+    const cy = 3 * y1;
+    const by = 3 * (y2 - y1) - cy;
+    const ay = 1 - cy - by;
+    const x = (t) => ((ax * t + bx) * t + cx) * t;
+    const y = (t) => ((ay * t + by) * t + cy) * t;
+    return {
+      x,
+      y
+    };
+  }
+  static cubicBezier(x1, y1, x2, y2) {
+    const { y } = _EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2);
+    return (t) => {
+      t = clamp(t);
+      return y(t);
+    };
+  }
+  static easeInEaseOut(t) {
+    return _EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EaseFunctions
+});
+//# sourceMappingURL=easeFunctions.js.map

package/dist/util/easeFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/easeFunctions.ts","../../src/util/math.ts"],"sourcesContent":["import { clamp } from './math'\n\nexport type EaseFunction = (t: number) => number\n\nexport class EaseFunctions {\n  static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): { x: EaseFunction, y: EaseFunction } {\n    // Calculate the x and y coordinates using the cubic Bézier formula\n    const cx = 3 * x1\n    const bx = 3 * (x2 - x1) - cx\n    const ax = 1 - cx - bx\n\n    const cy = 3 * y1\n    const by = 3 * (y2 - y1) - cy\n    const ay = 1 - cy - by\n\n    // Compute x and y values at parameter t\n    const x = (t: number) => ((ax * t + bx) * t + cx) * t\n    const y = (t: number) => ((ay * t + by) * t + cy) * t\n\n    return {\n      x,\n      y\n    }\n  }\n\n  static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction {\n    const { y } = EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2)\n    return (t: number) => {\n      t = clamp(t)\n      return y(t) // <= equal to x(t) * 0 + y(t) * 1\n    }\n  }\n\n  static easeInEaseOut(t: number): number {\n    return EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t)\n  };\n}\n","export const clamp = (value: number, min: number = 0, max: number = 1): number => {\n  return Math.min(Math.max(value, min), max)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,QAAQ,CAAC,OAAe,MAAc,GAAG,MAAc,MAAc;AAChF,SAAO,KAAK,IAAI,KAAK,IAAI,OAAO,GAAG,GAAG,GAAG;AAC3C;;;ADEO,IAAM,gBAAN,MAAM,eAAc;AAAA,EACzB,OAAO,mBAAmB,IAAY,IAAY,IAAY,IAAkD;AAE9G,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,KAAK,KAAK,MAAM;AAC3B,UAAM,KAAK,IAAI,KAAK;AAEpB,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,KAAK,KAAK,MAAM;AAC3B,UAAM,KAAK,IAAI,KAAK;AAGpB,UAAM,IAAI,CAAC,QAAgB,KAAK,IAAI,MAAM,IAAI,MAAM;AACpD,UAAM,IAAI,CAAC,QAAgB,KAAK,IAAI,MAAM,IAAI,MAAM;AAEpD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAO,YAAY,IAAY,IAAY,IAAY,IAA0B;AAC/E,UAAM,EAAE,EAAE,IAAI,eAAc,mBAAmB,IAAI,IAAI,IAAI,EAAE;AAC7D,WAAO,CAAC,MAAc;AACpB,UAAI,MAAM,CAAC;AACX,aAAO,EAAE,CAAC;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,OAAO,cAAc,GAAmB;AACtC,WAAO,eAAc,YAAY,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;AAAA,EACtD;AACF;","names":[]}

package/dist/util/easeFunctions.mjs

@@ -0,0 +1,36 @@
+// src/util/math.ts
+var clamp = (value, min = 0, max = 1) => {
+  return Math.min(Math.max(value, min), max);
+};
+
+// src/util/easeFunctions.ts
+var EaseFunctions = class _EaseFunctions {
+  static cubicBezierGeneric(x1, y1, x2, y2) {
+    const cx = 3 * x1;
+    const bx = 3 * (x2 - x1) - cx;
+    const ax = 1 - cx - bx;
+    const cy = 3 * y1;
+    const by = 3 * (y2 - y1) - cy;
+    const ay = 1 - cy - by;
+    const x = (t) => ((ax * t + bx) * t + cx) * t;
+    const y = (t) => ((ay * t + by) * t + cy) * t;
+    return {
+      x,
+      y
+    };
+  }
+  static cubicBezier(x1, y1, x2, y2) {
+    const { y } = _EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2);
+    return (t) => {
+      t = clamp(t);
+      return y(t);
+    };
+  }
+  static easeInEaseOut(t) {
+    return _EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t);
+  }
+};
+export {
+  EaseFunctions
+};
+//# sourceMappingURL=easeFunctions.mjs.map

package/dist/util/easeFunctions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/math.ts","../../src/util/easeFunctions.ts"],"sourcesContent":["export const clamp = (value: number, min: number = 0, max: number = 1): number => {\n  return Math.min(Math.max(value, min), max)\n}\n","import { clamp } from './math'\n\nexport type EaseFunction = (t: number) => number\n\nexport class EaseFunctions {\n  static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): { x: EaseFunction, y: EaseFunction } {\n    // Calculate the x and y coordinates using the cubic Bézier formula\n    const cx = 3 * x1\n    const bx = 3 * (x2 - x1) - cx\n    const ax = 1 - cx - bx\n\n    const cy = 3 * y1\n    const by = 3 * (y2 - y1) - cy\n    const ay = 1 - cy - by\n\n    // Compute x and y values at parameter t\n    const x = (t: number) => ((ax * t + bx) * t + cx) * t\n    const y = (t: number) => ((ay * t + by) * t + cy) * t\n\n    return {\n      x,\n      y\n    }\n  }\n\n  static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction {\n    const { y } = EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2)\n    return (t: number) => {\n      t = clamp(t)\n      return y(t) // <= equal to x(t) * 0 + y(t) * 1\n    }\n  }\n\n  static easeInEaseOut(t: number): number {\n    return EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t)\n  };\n}\n"],"mappings":";AAAO,IAAM,QAAQ,CAAC,OAAe,MAAc,GAAG,MAAc,MAAc;AAChF,SAAO,KAAK,IAAI,KAAK,IAAI,OAAO,GAAG,GAAG,GAAG;AAC3C;;;ACEO,IAAM,gBAAN,MAAM,eAAc;AAAA,EACzB,OAAO,mBAAmB,IAAY,IAAY,IAAY,IAAkD;AAE9G,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,KAAK,KAAK,MAAM;AAC3B,UAAM,KAAK,IAAI,KAAK;AAEpB,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,KAAK,KAAK,MAAM;AAC3B,UAAM,KAAK,IAAI,KAAK;AAGpB,UAAM,IAAI,CAAC,QAAgB,KAAK,IAAI,MAAM,IAAI,MAAM;AACpD,UAAM,IAAI,CAAC,QAAgB,KAAK,IAAI,MAAM,IAAI,MAAM;AAEpD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAO,YAAY,IAAY,IAAY,IAAY,IAA0B;AAC/E,UAAM,EAAE,EAAE,IAAI,eAAc,mBAAmB,IAAI,IAAI,IAAI,EAAE;AAC7D,WAAO,CAAC,MAAc;AACpB,UAAI,MAAM,CAAC;AACX,aAAO,EAAE,CAAC;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,OAAO,cAAc,GAAmB;AACtC,WAAO,eAAc,YAAY,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;AAAA,EACtD;AACF;","names":[]}

package/dist/util/emailValidation.d.mts

@@ -0,0 +1,3 @@
+declare const validateEmail: (email: string) => boolean;
+
+export { validateEmail };

package/dist/util/emailValidation.d.ts

@@ -1 +1,3 @@
-export declare const validateEmail: (email: string) => boolean;
+declare const validateEmail: (email: string) => boolean;
+
+export { validateEmail };

package/dist/util/emailValidation.js

@@ -1,3 +1,33 @@
-export const validateEmail = (email) => {
-    return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(email);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/emailValidation.ts
+var emailValidation_exports = {};
+__export(emailValidation_exports, {
+  validateEmail: () => validateEmail
+});
+module.exports = __toCommonJS(emailValidation_exports);
+var validateEmail = (email) => {
+  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(email);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateEmail
+});
+//# sourceMappingURL=emailValidation.js.map

package/dist/util/emailValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/emailValidation.ts"],"sourcesContent":["export const validateEmail = (email: string): boolean => {\n  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}$/i.test(email)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAM,gBAAgB,CAAC,UAA2B;AACvD,SAAO,2CAA2C,KAAK,KAAK;AAC9D;","names":[]}

package/dist/util/emailValidation.mjs

@@ -0,0 +1,8 @@
+// src/util/emailValidation.ts
+var validateEmail = (email) => {
+  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(email);
+};
+export {
+  validateEmail
+};
+//# sourceMappingURL=emailValidation.mjs.map

package/dist/util/emailValidation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/emailValidation.ts"],"sourcesContent":["export const validateEmail = (email: string): boolean => {\n  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}$/i.test(email)\n}\n"],"mappings":";AAAO,IAAM,gBAAgB,CAAC,UAA2B;AACvD,SAAO,2CAA2C,KAAK,KAAK;AAC9D;","names":[]}

package/dist/util/loopingArray.d.mts

@@ -0,0 +1,25 @@
+/**
+ *  1 is forwards
+ *
+ * -1 is backwards
+ */
+type Direction = 1 | -1;
+declare class LoopingArrayCalculator {
+    length: number;
+    isLooping: boolean;
+    allowedOverScroll: number;
+    constructor(length: number, isLooping?: boolean, allowedOverScroll?: number);
+    getCorrectedPosition(position: number): number;
+    static withoutOffset(position: number): number;
+    static getOffset(position: number): number;
+    /**
+     * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
+     */
+    getDistanceDirectional(position: number, target: number, direction: Direction): number;
+    getDistanceForward(position: number, target: number): number;
+    getDistanceBackward(position: number, target: number): number;
+    getDistance(position: number, target: number): number;
+    getBestDirection(position: number, target: number): Direction;
+}
+
+export { type Direction, LoopingArrayCalculator };

package/dist/util/loopingArray.d.ts

@@ -3,8 +3,8 @@
  *
  * -1 is backwards
  */
-export type Direction = 1 | -1;
-export declare class LoopingArrayCalculator {
+type Direction = 1 | -1;
+declare class LoopingArrayCalculator {
     length: number;
     isLooping: boolean;
     allowedOverScroll: number;
@@ -21,3 +21,5 @@ export declare class LoopingArrayCalculator {
     getDistance(position: number, target: number): number;
     getBestDirection(position: number, target: number): Direction;
 }
+
+export { type Direction, LoopingArrayCalculator };

package/dist/util/loopingArray.js

@@ -1,67 +1,97 @@
-export class LoopingArrayCalculator {
-    constructor(length, isLooping = true, allowedOverScroll = 0.1) {
-        if (allowedOverScroll < 0 || length < 1) {
-            throw new Error('Invalid parameters: allowedOverScroll >= 0 and length >= 1 must be true');
-        }
-        this.length = length;
-        this.isLooping = isLooping;
-        this.allowedOverScroll = allowedOverScroll;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/loopingArray.ts
+var loopingArray_exports = {};
+__export(loopingArray_exports, {
+  LoopingArrayCalculator: () => LoopingArrayCalculator
+});
+module.exports = __toCommonJS(loopingArray_exports);
+var LoopingArrayCalculator = class _LoopingArrayCalculator {
+  constructor(length, isLooping = true, allowedOverScroll = 0.1) {
+    if (allowedOverScroll < 0 || length < 1) {
+      throw new Error("Invalid parameters: allowedOverScroll >= 0 and length >= 1 must be true");
     }
-    getCorrectedPosition(position) {
-        if (!this.isLooping) {
-            return Math.max(-this.allowedOverScroll, Math.min(this.allowedOverScroll + this.length - 1, position));
-        }
-        if (position >= this.length) {
-            return position % this.length;
-        }
-        if (position < 0) {
-            return this.length - (Math.abs(position) % this.length);
-        }
-        return position;
+    this.length = length;
+    this.isLooping = isLooping;
+    this.allowedOverScroll = allowedOverScroll;
+  }
+  getCorrectedPosition(position) {
+    if (!this.isLooping) {
+      return Math.max(-this.allowedOverScroll, Math.min(this.allowedOverScroll + this.length - 1, position));
     }
-    static withoutOffset(position) {
-        return position + LoopingArrayCalculator.getOffset(position);
+    if (position >= this.length) {
+      return position % this.length;
     }
-    static getOffset(position) {
-        return Math.round(position) - position; // For example: 45.5 => 46 - 45.5 = 0.5
+    if (position < 0) {
+      return this.length - Math.abs(position) % this.length;
     }
-    /**
-     * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
-     */
-    getDistanceDirectional(position, target, direction) {
-        if (!this.isLooping && (position < -this.allowedOverScroll || position > this.allowedOverScroll + this.length - 1)) {
-            throw new Error('Invalid parameters: position is out of bounds.');
-        }
-        const isForwardInvalid = (direction === 1 && position > target);
-        const isBackwardInvalid = (direction === -1 && target < position);
-        if (!this.isLooping && (isForwardInvalid || isBackwardInvalid)) {
-            return Infinity;
-        }
-        if (direction === -1) {
-            return this.getDistanceDirectional(target, position, 1);
-        }
-        position = this.getCorrectedPosition(position);
-        target = this.getCorrectedPosition(target);
-        let distance = (target - position) * direction;
-        if (distance < 0) {
-            distance = this.length - (Math.abs(position) % this.length) + target;
-        }
-        return distance;
+    return position;
+  }
+  static withoutOffset(position) {
+    return position + _LoopingArrayCalculator.getOffset(position);
+  }
+  static getOffset(position) {
+    return Math.round(position) - position;
+  }
+  /**
+   * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
+   */
+  getDistanceDirectional(position, target, direction) {
+    if (!this.isLooping && (position < -this.allowedOverScroll || position > this.allowedOverScroll + this.length - 1)) {
+      throw new Error("Invalid parameters: position is out of bounds.");
     }
-    getDistanceForward(position, target) {
-        return this.getDistanceDirectional(position, target, 1);
+    const isForwardInvalid = direction === 1 && position > target;
+    const isBackwardInvalid = direction === -1 && target < position;
+    if (!this.isLooping && (isForwardInvalid || isBackwardInvalid)) {
+      return Infinity;
     }
-    getDistanceBackward(position, target) {
-        return this.getDistanceDirectional(position, target, -1);
+    if (direction === -1) {
+      return this.getDistanceDirectional(target, position, 1);
     }
-    getDistance(position, target) {
-        const forwardDistance = this.getDistanceForward(position, target);
-        const backwardDistance = this.getDistanceBackward(position, target);
-        return Math.min(forwardDistance, backwardDistance);
+    position = this.getCorrectedPosition(position);
+    target = this.getCorrectedPosition(target);
+    let distance = (target - position) * direction;
+    if (distance < 0) {
+      distance = this.length - Math.abs(position) % this.length + target;
     }
-    getBestDirection(position, target) {
-        const forwardDistance = this.getDistanceForward(position, target);
-        const backwardDistance = this.getDistanceBackward(position, target);
-        return forwardDistance < backwardDistance ? 1 : -1;
-    }
-}
+    return distance;
+  }
+  getDistanceForward(position, target) {
+    return this.getDistanceDirectional(position, target, 1);
+  }
+  getDistanceBackward(position, target) {
+    return this.getDistanceDirectional(position, target, -1);
+  }
+  getDistance(position, target) {
+    const forwardDistance = this.getDistanceForward(position, target);
+    const backwardDistance = this.getDistanceBackward(position, target);
+    return Math.min(forwardDistance, backwardDistance);
+  }
+  getBestDirection(position, target) {
+    const forwardDistance = this.getDistanceForward(position, target);
+    const backwardDistance = this.getDistanceBackward(position, target);
+    return forwardDistance < backwardDistance ? 1 : -1;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoopingArrayCalculator
+});
+//# sourceMappingURL=loopingArray.js.map

package/dist/util/loopingArray.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/loopingArray.ts"],"sourcesContent":["/**\n *  1 is forwards\n *\n * -1 is backwards\n */\nexport type Direction = 1 | -1\n\nexport class LoopingArrayCalculator {\n  length: number\n  isLooping: boolean\n  allowedOverScroll: number\n\n  constructor(length: number, isLooping: boolean = true, allowedOverScroll: number = 0.1) {\n    if (allowedOverScroll < 0 || length < 1) {\n      throw new Error('Invalid parameters: allowedOverScroll >= 0 and length >= 1 must be true')\n    }\n\n    this.length = length\n    this.isLooping = isLooping\n    this.allowedOverScroll = allowedOverScroll\n  }\n\n  getCorrectedPosition(position: number): number {\n    if (!this.isLooping) {\n      return Math.max(-this.allowedOverScroll, Math.min(this.allowedOverScroll + this.length - 1, position))\n    }\n    if (position >= this.length) {\n      return position % this.length\n    }\n    if (position < 0) {\n      return this.length - (Math.abs(position) % this.length)\n    }\n    return position\n  }\n\n  static withoutOffset(position: number): number {\n    return position + LoopingArrayCalculator.getOffset(position)\n  }\n\n  static getOffset(position: number): number {\n    return Math.round(position) - position // For example: 45.5 => 46 - 45.5 = 0.5\n  }\n\n  /**\n   * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)\n   */\n  getDistanceDirectional(position: number, target: number, direction: Direction): number {\n    if (!this.isLooping && (position < -this.allowedOverScroll || position > this.allowedOverScroll + this.length - 1)) {\n      throw new Error('Invalid parameters: position is out of bounds.')\n    }\n\n    const isForwardInvalid = (direction === 1 && position > target)\n    const isBackwardInvalid = (direction === -1 && target < position)\n\n    if (!this.isLooping && (isForwardInvalid || isBackwardInvalid)) {\n      return Infinity\n    }\n\n    if (direction === -1) {\n      return this.getDistanceDirectional(target, position, 1)\n    }\n\n    position = this.getCorrectedPosition(position)\n    target = this.getCorrectedPosition(target)\n\n    let distance = (target - position) * direction\n    if (distance < 0) {\n      distance = this.length - (Math.abs(position) % this.length) + target\n    }\n\n    return distance\n  }\n\n  getDistanceForward(position: number, target: number): number {\n    return this.getDistanceDirectional(position, target, 1)\n  }\n\n  getDistanceBackward(position: number, target: number): number {\n    return this.getDistanceDirectional(position, target, -1)\n  }\n\n  getDistance(position: number, target: number): number {\n    const forwardDistance = this.getDistanceForward(position, target)\n    const backwardDistance = this.getDistanceBackward(position, target)\n\n    return Math.min(forwardDistance, backwardDistance)\n  }\n\n  getBestDirection(position: number, target: number): Direction {\n    const forwardDistance = this.getDistanceForward(position, target)\n    const backwardDistance = this.getDistanceBackward(position, target)\n    return forwardDistance < backwardDistance ? 1 : -1\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,IAAM,yBAAN,MAAM,wBAAuB;AAAA,EAKlC,YAAY,QAAgB,YAAqB,MAAM,oBAA4B,KAAK;AACtF,QAAI,oBAAoB,KAAK,SAAS,GAAG;AACvC,YAAM,IAAI,MAAM,yEAAyE;AAAA,IAC3F;AAEA,SAAK,SAAS;AACd,SAAK,YAAY;AACjB,SAAK,oBAAoB;AAAA,EAC3B;AAAA,EAEA,qBAAqB,UAA0B;AAC7C,QAAI,CAAC,KAAK,WAAW;AACnB,aAAO,KAAK,IAAI,CAAC,KAAK,mBAAmB,KAAK,IAAI,KAAK,oBAAoB,KAAK,SAAS,GAAG,QAAQ,CAAC;AAAA,IACvG;AACA,QAAI,YAAY,KAAK,QAAQ;AAC3B,aAAO,WAAW,KAAK;AAAA,IACzB;AACA,QAAI,WAAW,GAAG;AAChB,aAAO,KAAK,SAAU,KAAK,IAAI,QAAQ,IAAI,KAAK;AAAA,IAClD;AACA,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,cAAc,UAA0B;AAC7C,WAAO,WAAW,wBAAuB,UAAU,QAAQ;AAAA,EAC7D;AAAA,EAEA,OAAO,UAAU,UAA0B;AACzC,WAAO,KAAK,MAAM,QAAQ,IAAI;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAKA,uBAAuB,UAAkB,QAAgB,WAA8B;AACrF,QAAI,CAAC,KAAK,cAAc,WAAW,CAAC,KAAK,qBAAqB,WAAW,KAAK,oBAAoB,KAAK,SAAS,IAAI;AAClH,YAAM,IAAI,MAAM,gDAAgD;AAAA,IAClE;AAEA,UAAM,mBAAoB,cAAc,KAAK,WAAW;AACxD,UAAM,oBAAqB,cAAc,MAAM,SAAS;AAExD,QAAI,CAAC,KAAK,cAAc,oBAAoB,oBAAoB;AAC9D,aAAO;AAAA,IACT;AAEA,QAAI,cAAc,IAAI;AACpB,aAAO,KAAK,uBAAuB,QAAQ,UAAU,CAAC;AAAA,IACxD;AAEA,eAAW,KAAK,qBAAqB,QAAQ;AAC7C,aAAS,KAAK,qBAAqB,MAAM;AAEzC,QAAI,YAAY,SAAS,YAAY;AACrC,QAAI,WAAW,GAAG;AAChB,iBAAW,KAAK,SAAU,KAAK,IAAI,QAAQ,IAAI,KAAK,SAAU;AAAA,IAChE;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,mBAAmB,UAAkB,QAAwB;AAC3D,WAAO,KAAK,uBAAuB,UAAU,QAAQ,CAAC;AAAA,EACxD;AAAA,EAEA,oBAAoB,UAAkB,QAAwB;AAC5D,WAAO,KAAK,uBAAuB,UAAU,QAAQ,EAAE;AAAA,EACzD;AAAA,EAEA,YAAY,UAAkB,QAAwB;AACpD,UAAM,kBAAkB,KAAK,mBAAmB,UAAU,MAAM;AAChE,UAAM,mBAAmB,KAAK,oBAAoB,UAAU,MAAM;AAElE,WAAO,KAAK,IAAI,iBAAiB,gBAAgB;AAAA,EACnD;AAAA,EAEA,iBAAiB,UAAkB,QAA2B;AAC5D,UAAM,kBAAkB,KAAK,mBAAmB,UAAU,MAAM;AAChE,UAAM,mBAAmB,KAAK,oBAAoB,UAAU,MAAM;AAClE,WAAO,kBAAkB,mBAAmB,IAAI;AAAA,EAClD;AACF;","names":[]}