tsu 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,9 +1,328 @@
-export * from './array';
-export * from './function';
-export * from './is';
-export * from './maths';
-export * from './misc';
-export * from './object';
-export * from './scroll';
-export * from './string';
-export * from './types';
+declare type Arrayable<T> = T | Array<T>;
+declare type Nullable<T> = T | null | undefined;
+declare type Fn<T = any> = (...args: any[]) => T;
+declare type VoidFn = Fn<void>;
+declare type Obj<V = unknown> = Record<string | symbol | number, V>;
+
+/**
+ * Removes the first n items of an array.
+ *
+ * @param n - The number of items to remove.
+ * @param array - The array.
+ * @returns The remaining items.
+ */
+declare function drop<T>(n: number, array: readonly T[]): T[];
+/**
+ * Returns the first item of an array.
+ *
+ * @param array - The array.
+ * @returns The first item.
+ */
+declare function head<T>(array: readonly T[]): T;
+/**
+ * Returns all but the last item of an array.
+ *
+ * @param array - The array.
+ * @returns The array without the last item.
+ */
+declare function init<T>(array: readonly T[]): T[];
+/**
+ * Returns the last item of an array.
+ *
+ * @param array - The array.
+ * @returns The last item.
+ */
+declare function last<T>(array: readonly T[]): T;
+/**
+ * Returns the maximum number of an array.
+ *
+ * @param array - The array of numbers.
+ * @returns The maximum number.
+ */
+declare function max(array: readonly number[]): number | undefined;
+/**
+ * Returns the minimum number of an array.
+ *
+ * @param array - The array of numbers.
+ * @returns The minimum number.
+ */
+declare function min(array: readonly number[]): number | undefined;
+/**
+ * Splits an array into two based on a predicate function.
+ *
+ * @param filter - The predicate function.
+ * @param array - The array.
+ * @returns The array split in two.
+ */
+declare function partition<T>(filter: (x: T, idx: number, arr: readonly T[]) => boolean, array: readonly T[]): [T[], T[]];
+/**
+ * Splits an array into two at a given index.
+ *
+ * @param i - The position to split at.
+ * @param array - The array.
+ * @returns The array split in two.
+ */
+declare function splitAt<T>(i: number, array: readonly T[]): [T[], T[]];
+/**
+ * Returns the sum of the numbers of an array.
+ *
+ * @param array - The array of numbers.
+ * @returns The sum.
+ */
+declare function sum(array: readonly number[]): number;
+/**
+ * Returns all but the first item of an array.
+ *
+ * @param array - The array.
+ * @returns The array without the first item.
+ */
+declare function tail<T>(array: readonly T[]): T[];
+/**
+ * Returns the first n items of an array.
+ *
+ * @param n - The number of items to return.
+ * @param array - The array.
+ * @returns The first n items.
+ */
+declare function take<T>(n: number, array: readonly T[]): T[];
+/**
+ * Wraps a single value of an array, if not already an array.
+ *
+ * @param maybeArray - The value to wrap, or the existing array.
+ * @returns The item wrapped in an array, or the provided array.
+ */
+declare function toArray<T>(maybeArray: Nullable<Arrayable<T>>): T[];
+/**
+ * Removes duplicate primitive values from an array.
+ *
+ * @param array - The array.
+ * @returns The array without duplicated primitive values.
+ */
+declare function uniq<T>(array: readonly T[]): T[];
+
+/**
+ * Prevents a function from running until it hasn't been called for a certain time period.
+ *
+ * @param fn - The function.
+ * @param delay - The time period (in ms).
+ * @returns The debounced function.
+ */
+declare function debounce(fn: Fn, delay: number): VoidFn;
+/**
+ * Optimises subsequent calls of a function by caching return values.
+ *
+ * @param fn - The function.
+ * @returns The memoized function.
+ */
+declare function memoize<T>(fn: Fn<T>): Fn<T>;
+/**
+ * Prevents a function from running for some time period after it was last called.
+ *
+ * @param fn - The function.
+ * @param limit - The time period.
+ * @returns The throttled function.
+ */
+declare function throttle(fn: Fn, limit: number): VoidFn;
+
+/**
+ * Identifies if a value is an array.
+ *
+ * @param val - The value.
+ * @returns If the value is an array.
+ */
+declare function isArray(val: unknown): val is any[];
+/**
+ * Identifies if a value is a boolean.
+ *
+ * @param val - The value.
+ * @returns If the value is a boolean.
+ */
+declare function isBoolean(val: unknown): val is boolean;
+/**
+ * Identifies if the code is being run in the browser.
+ *
+ * @returns If the code is being run on a browser.
+ */
+declare function isBrowser(): boolean;
+/**
+ * Identifies if a value is defined.
+ *
+ * @param val - The value.
+ * @returns If the value is defined.
+ */
+declare function isDefined<T = unknown>(val?: T): val is T;
+/**
+ * Identifies if a value is a function.
+ *
+ * @param val - The value.
+ * @returns If the value is a function.
+ */
+declare function isFunction<T extends Fn>(val: unknown): val is T;
+/**
+ * Identifies if a value is a number.
+ *
+ * @param val - The value.
+ * @returns If the value is a number.
+ */
+declare function isNumber(val: unknown): val is number;
+/**
+ * Identifies if a value is an object.
+ *
+ * @param val - The value.
+ * @returns If the value is an object.
+ */
+declare function isObject(val: unknown): val is Obj;
+/**
+ * Identifies if a value is a string.
+ *
+ * @param val - The value.
+ * @returns If the value is a string.
+ */
+declare function isString(val: unknown): val is string;
+/**
+ * Identifies if a value is the global window.
+ *
+ * @param val - The value.
+ * @returns If the value is the global window.
+ */
+declare function isWindow(val: unknown): val is Window;
+
+/**
+ * Identifies if a number is even.
+ *
+ * @param n - The number.
+ * @returns If the number is even.
+ */
+declare function isEven(n: number): boolean;
+/**
+ * Identifies if a number is odd.
+ *
+ * @param n - The number.
+ * @returns If the number is odd.
+ */
+declare function isOdd(n: number): boolean;
+/**
+ * Opinionated implementation of modulo (%).
+ *
+ * @param n - The dividend.
+ * @param m - The divisor.
+ * @returns The remainder of dividing n by m.
+ */
+declare function modulo(n: number, m: number): number;
+/**
+ * Generates a random integer between bounds.
+ *
+ * @param max - The exclusive maximum bound.
+ * @param min - The inclusive minimum bound.
+ * @returns The random integer.
+ */
+declare function randomNumber(max: number, min?: number): number;
+/**
+ * Rolls an n-sided die.
+ *
+ * @param n - The number of sides on the die.
+ * @returns If the die roll was 0.
+ */
+declare function randomChance(n: number): boolean;
+
+/**
+ * Does nothing.
+ *
+ * @returns Nothing.
+ */
+declare function noop(): void;
+/**
+ * Halts program execution for a specified time.
+ *
+ * @param duration - The time to wait (in ms).
+ * @returns The halting promise.
+ */
+declare function sleep(duration: number): Promise<void>;
+
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Recursively merges multiple objects into one.
+ *
+ * @param objects - The objects to merge.
+ * @returns The merged object.
+ */
+declare function deepMerge<T extends Obj<any>[]>(...objects: T): UnionToIntersection<T[number]>;
+
+declare type ScrollConfig = {
+    to: Element | string | number;
+    offset?: number;
+    duration?: number;
+    container?: Element | string | null;
+};
+/**
+ * Scrolls the page or provided container to a target element or y-coordinate.
+ *
+ * @param config - The scroll config.
+ * @param config.to - The scroll target.
+ * @param config.offset - The offset from the scroll target (in px).
+ * @param config.duration - The scroll duration (in ms).
+ * @param config.container - The container to scroll in.
+ */
+declare function scroll({ to, offset, duration, container }: ScrollConfig): void;
+
+/**
+ * Capitalises the first letter of one word, or all words, in a string.
+ *
+ * @param str - The string.
+ * @param allWords - If all words should be capitalised.
+ * @returns The capitalised string.
+ */
+declare function capitalise(str: string, allWords?: boolean): string;
+/**
+ * Separates a string into an array of characters.
+ *
+ * @param str - The string.
+ * @returns The string's characters.
+ */
+declare function chars(str: string): string[];
+/**
+ * Identifies strings which only contain whitespace.
+ *
+ * @param str - The string.
+ * @returns If the string is blank.
+ */
+declare function isBlank(str: string): boolean;
+/**
+ * Identifies empty strings.
+ *
+ * @param str - The string.
+ * @returns If the string is empty.
+ */
+declare function isEmpty(str: string): boolean;
+/**
+ * Converts a kebab case string to camel case.
+ *
+ * @param str - The kebab case string.
+ * @returns The camel case string.
+ */
+declare function toCamel(str: string): string;
+/**
+ * Converts a camel case string to kebab case.
+ *
+ * @param str - The camel case string.
+ * @returns The kebab case string.
+ */
+declare function toKebab(str: string): string;
+/**
+ * Converts a string which contains a number to the number itself.
+ *
+ * @param str - The string.
+ * @returns The number.
+ */
+declare function toNumber(str: string): number;
+/**
+ * Truncates a string to a provided length.
+ *
+ * @param str - The string.
+ * @param length - The length.
+ * @param truncateStr - The prefix to apply after truncation.
+ * @returns The truncated string.
+ */
+declare function truncate(str: string, length: number, truncateStr?: string): string;
+
+export { Arrayable, Fn, Nullable, Obj, VoidFn, capitalise, chars, debounce, deepMerge, drop, head, init, isArray, isBlank, isBoolean, isBrowser, isDefined, isEmpty, isEven, isFunction, isNumber, isObject, isOdd, isString, isWindow, last, max, memoize, min, modulo, noop, partition, randomChance, randomNumber, scroll, sleep, splitAt, sum, tail, take, throttle, toArray, toCamel, toKebab, toNumber, truncate, uniq };

package/dist/index.js

@@ -1,8 +1,362 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
 
-'use strict'
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  capitalise: () => capitalise,
+  chars: () => chars,
+  debounce: () => debounce,
+  deepMerge: () => deepMerge,
+  drop: () => drop,
+  head: () => head,
+  init: () => init,
+  isArray: () => isArray,
+  isBlank: () => isBlank,
+  isBoolean: () => isBoolean,
+  isBrowser: () => isBrowser,
+  isDefined: () => isDefined,
+  isEmpty: () => isEmpty,
+  isEven: () => isEven,
+  isFunction: () => isFunction,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isOdd: () => isOdd,
+  isString: () => isString,
+  isWindow: () => isWindow,
+  last: () => last,
+  max: () => max,
+  memoize: () => memoize,
+  min: () => min,
+  modulo: () => modulo,
+  noop: () => noop,
+  partition: () => partition,
+  randomChance: () => randomChance,
+  randomNumber: () => randomNumber,
+  scroll: () => scroll,
+  sleep: () => sleep,
+  splitAt: () => splitAt,
+  sum: () => sum,
+  tail: () => tail,
+  take: () => take,
+  throttle: () => throttle,
+  toArray: () => toArray,
+  toCamel: () => toCamel,
+  toKebab: () => toKebab,
+  toNumber: () => toNumber,
+  truncate: () => truncate,
+  uniq: () => uniq
+});
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./tsu.cjs.production.min.js')
-} else {
-  module.exports = require('./tsu.cjs.development.js')
+// src/array.ts
+function drop(n, array) {
+  if (n <= 0) {
+    return [...array];
+  }
+  return array.slice(n);
 }
+function head(array) {
+  return array[0];
+}
+function init(array) {
+  return array.slice(0, array.length - 1);
+}
+function last(array) {
+  return array[array.length - 1];
+}
+function max(array) {
+  if (!array.length) {
+    return;
+  }
+  return Math.max(...array);
+}
+function min(array) {
+  if (!array.length) {
+    return;
+  }
+  return Math.min(...array);
+}
+function partition(filter, array) {
+  return array.reduce(([passed, failed], item, idx, arr) => {
+    if (filter(item, idx, arr)) {
+      return [[...passed, item], failed];
+    }
+    return [passed, [...failed, item]];
+  }, [[], []]);
+}
+function splitAt(i, array) {
+  if (i <= 0) {
+    return [[], [...array]];
+  }
+  return [array.slice(0, i), array.slice(i)];
+}
+function sum(array) {
+  if (!array.length) {
+    return 0;
+  }
+  return array.reduce((sum2, current) => sum2 + current, 0);
+}
+function tail(array) {
+  return array.slice(1);
+}
+function take(n, array) {
+  if (n <= 0) {
+    return [];
+  }
+  return array.slice(0, n);
+}
+function toArray(maybeArray) {
+  if (!maybeArray) {
+    return [];
+  }
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+function uniq(array) {
+  return Array.from(new Set(array));
+}
+
+// src/function.ts
+function debounce(fn, delay) {
+  let timeout;
+  return function(...args) {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      clearTimeout(timeout);
+      fn(...args);
+    }, delay);
+  };
+}
+function memoize(fn) {
+  const cache = {};
+  return function(...args) {
+    const argsString = JSON.stringify(args);
+    if (argsString in cache) {
+      return cache[argsString];
+    }
+    const result = fn(...args);
+    cache[argsString] = result;
+    return result;
+  };
+}
+function throttle(fn, limit) {
+  let isWaiting = false;
+  return function(...args) {
+    if (!isWaiting) {
+      fn(...args);
+      isWaiting = true;
+      setTimeout(() => {
+        isWaiting = false;
+      }, limit);
+    }
+  };
+}
+
+// src/is.ts
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isBoolean(val) {
+  return typeof val === "boolean";
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function isDefined(val) {
+  return typeof val !== "undefined";
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isWindow(val) {
+  return isBrowser() && toString.call(val) === "[object Window]";
+}
+
+// src/maths.ts
+function isEven(n) {
+  return n % 2 === 0;
+}
+function isOdd(n) {
+  return n % 2 !== 0;
+}
+function modulo(n, m) {
+  return n - Math.floor(n / m) * m;
+}
+function randomNumber(max2, min2 = 0) {
+  return Math.floor(Math.random() * (max2 - min2)) + min2;
+}
+function randomChance(n) {
+  return randomNumber(n) === 0;
+}
+
+// src/misc.ts
+function noop() {
+  return;
+}
+async function sleep(duration) {
+  return new Promise((resolve) => setTimeout(resolve, duration));
+}
+
+// src/object.ts
+function deepMerge(...objects) {
+  return objects.reduce((result, current) => {
+    Object.keys(current).forEach((key) => {
+      if (isArray(result[key]) && isArray(current[key])) {
+        result[key] = uniq(result[key].concat(current[key]));
+      } else if (isObject(result[key]) && isObject(current[key])) {
+        result[key] = deepMerge(result[key], current[key]);
+      } else {
+        result[key] = current[key];
+      }
+    });
+    return result;
+  }, {});
+}
+
+// src/scroll.ts
+function scroll({
+  to,
+  offset = 0,
+  duration = 1e3,
+  container = null
+}) {
+  const target = isString(to) ? document.querySelector(to) : to;
+  const _container = isString(container) ? document.querySelector(container) : container;
+  const start = (_container == null ? void 0 : _container.scrollTop) || (window == null ? void 0 : window.pageYOffset) || 0;
+  const end = (isNumber(target) ? target : getElTop(target, start)) + offset;
+  const startTime = Date.now();
+  function step() {
+    const timeElapsed = Date.now() - startTime;
+    const isScrolling = timeElapsed < duration;
+    const position = isScrolling ? getPosition(start, end, timeElapsed, duration) : end;
+    if (isScrolling) {
+      requestAnimationFrame(step);
+    }
+    if (_container) {
+      _container.scrollTop = position;
+    } else {
+      window.scrollTo(0, position);
+    }
+  }
+  step();
+}
+function easing(t) {
+  return t < 0.5 ? 4 * Math.pow(t, 3) : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+}
+function getPosition(s, e, t, d) {
+  return s + (e - s) * easing(t / d);
+}
+function getElTop(element, start) {
+  return element.nodeName === "HTML" ? -start : element.getBoundingClientRect().top + start;
+}
+
+// src/string.ts
+function capitalise(str, allWords = false) {
+  if (!allWords) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return str.split(" ").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ");
+}
+function chars(str) {
+  return str.split("");
+}
+function isBlank(str) {
+  return str.trim().length === 0;
+}
+function isEmpty(str) {
+  return str.length === 0;
+}
+function toCamel(str) {
+  const RE = /-(\w)/g;
+  return str.replace(RE, (_, c) => c ? c.toUpperCase() : "");
+}
+function toKebab(str) {
+  const RE = /\B([A-Z])/g;
+  return str.replace(RE, "-$1").toLowerCase();
+}
+function toNumber(str) {
+  if (!str.length) {
+    return NaN;
+  }
+  return Number(str.replace(/[#£€$,%]/g, ""));
+}
+function truncate(str, length, truncateStr = "...") {
+  if (length <= 0) {
+    return truncateStr;
+  }
+  return str.slice(0, length) + truncateStr;
+}
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  capitalise,
+  chars,
+  debounce,
+  deepMerge,
+  drop,
+  head,
+  init,
+  isArray,
+  isBlank,
+  isBoolean,
+  isBrowser,
+  isDefined,
+  isEmpty,
+  isEven,
+  isFunction,
+  isNumber,
+  isObject,
+  isOdd,
+  isString,
+  isWindow,
+  last,
+  max,
+  memoize,
+  min,
+  modulo,
+  noop,
+  partition,
+  randomChance,
+  randomNumber,
+  scroll,
+  sleep,
+  splitAt,
+  sum,
+  tail,
+  take,
+  throttle,
+  toArray,
+  toCamel,
+  toKebab,
+  toNumber,
+  truncate,
+  uniq
+});