@ciwergrp/nuxid 1.0.2-release

package/dist/runtime/helper/array/index.d.ts

@@ -0,0 +1,46 @@
+import { collapse } from './collapse.js';
+import { crossJoin } from './crossJoin.js';
+import { every } from './every.js';
+import { first } from './first.js';
+import { flatten } from './flatten.js';
+import { join } from './join.js';
+import { last } from './last.js';
+import { map } from './map.js';
+import { mapSpread } from './mapSpread.js';
+import { partition } from './partition.js';
+import { random } from './random.js';
+import { reject } from './reject.js';
+import { shuffle } from './shuffle.js';
+import { sole } from './sole.js';
+import { some } from './some.js';
+import { sort } from './sort.js';
+import { sortDesc } from './sortDesc.js';
+import { take } from './take.js';
+import { where } from './where.js';
+import { whereNotNull } from './whereNotNull.js';
+import { wrap } from './wrap.js';
+export interface ArrayHelper {
+    collapse: typeof collapse;
+    crossJoin: typeof crossJoin;
+    every: typeof every;
+    first: typeof first;
+    flatten: typeof flatten;
+    join: typeof join;
+    last: typeof last;
+    map: typeof map;
+    mapSpread: typeof mapSpread;
+    partition: typeof partition;
+    random: typeof random;
+    reject: typeof reject;
+    shuffle: typeof shuffle;
+    sole: typeof sole;
+    some: typeof some;
+    sort: typeof sort;
+    sortDesc: typeof sortDesc;
+    take: typeof take;
+    where: typeof where;
+    whereNotNull: typeof whereNotNull;
+    wrap: typeof wrap;
+}
+export declare function array(): ArrayHelper;
+export { collapse, crossJoin, every, first, flatten, join, last, map, mapSpread, partition, random, reject, shuffle, sole, some, sort, sortDesc, take, where, whereNotNull, wrap, };

package/dist/runtime/helper/array/index.js

@@ -0,0 +1,69 @@
+import { collapse } from "./collapse.js";
+import { crossJoin } from "./crossJoin.js";
+import { every } from "./every.js";
+import { first } from "./first.js";
+import { flatten } from "./flatten.js";
+import { join } from "./join.js";
+import { last } from "./last.js";
+import { map } from "./map.js";
+import { mapSpread } from "./mapSpread.js";
+import { partition } from "./partition.js";
+import { random } from "./random.js";
+import { reject } from "./reject.js";
+import { shuffle } from "./shuffle.js";
+import { sole } from "./sole.js";
+import { some } from "./some.js";
+import { sort } from "./sort.js";
+import { sortDesc } from "./sortDesc.js";
+import { take } from "./take.js";
+import { where } from "./where.js";
+import { whereNotNull } from "./whereNotNull.js";
+import { wrap } from "./wrap.js";
+export function array() {
+  return {
+    collapse,
+    crossJoin,
+    every,
+    first,
+    flatten,
+    join,
+    last,
+    map,
+    mapSpread,
+    partition,
+    random,
+    reject,
+    shuffle,
+    sole,
+    some,
+    sort,
+    sortDesc,
+    take,
+    where,
+    whereNotNull,
+    wrap
+  };
+}
+export {
+  collapse,
+  crossJoin,
+  every,
+  first,
+  flatten,
+  join,
+  last,
+  map,
+  mapSpread,
+  partition,
+  random,
+  reject,
+  shuffle,
+  sole,
+  some,
+  sort,
+  sortDesc,
+  take,
+  where,
+  whereNotNull,
+  wrap
+};

package/dist/runtime/helper/array/join.d.ts

@@ -0,0 +1 @@
+export declare function join(array: any[], glue: string, finalGlue?: string): string;

package/dist/runtime/helper/array/join.js

@@ -0,0 +1,11 @@
+export function join(array, glue, finalGlue = "") {
+  if (!array.length) {
+    return "";
+  }
+  if (!finalGlue || array.length < 2) {
+    return array.join(glue);
+  }
+  const head = array.slice(0, -1).join(glue);
+  const tail = array[array.length - 1];
+  return `${head}${finalGlue}${tail}`;
+}

package/dist/runtime/helper/array/last.d.ts

@@ -0,0 +1 @@
+export declare function last<T>(array: T[], callback?: (item: T, index: number) => boolean, defaultValue?: T | null): T | null;

package/dist/runtime/helper/array/last.js

@@ -0,0 +1,11 @@
+export function last(array, callback, defaultValue = null) {
+  if (!callback) {
+    return array.length ? array[array.length - 1] : defaultValue;
+  }
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (callback(array[i], i)) {
+      return array[i];
+    }
+  }
+  return defaultValue;
+}

package/dist/runtime/helper/array/map.d.ts

@@ -0,0 +1 @@
+export declare function map<T, U>(array: T[], callback: (item: T, index: number) => U): U[];

package/dist/runtime/helper/array/map.js

@@ -0,0 +1,3 @@
+export function map(array, callback) {
+  return array.map(callback);
+}

package/dist/runtime/helper/array/mapSpread.d.ts

@@ -0,0 +1 @@
+export declare function mapSpread<T extends any[], U>(array: T[], callback: (...args: T) => U): U[];

package/dist/runtime/helper/array/mapSpread.js

@@ -0,0 +1,3 @@
+export function mapSpread(array, callback) {
+  return array.map((item) => callback(...item));
+}

package/dist/runtime/helper/array/partition.d.ts

@@ -0,0 +1 @@
+export declare function partition<T>(array: T[], predicate: (item: T, index: number) => boolean): [T[], T[]];

package/dist/runtime/helper/array/partition.js

@@ -0,0 +1,12 @@
+export function partition(array, predicate) {
+  const pass = [];
+  const fail = [];
+  array.forEach((item, index) => {
+    if (predicate(item, index)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  });
+  return [pass, fail];
+}

package/dist/runtime/helper/array/random.d.ts

@@ -0,0 +1 @@
+export declare function random<T>(array: T[], count?: number): T | T[] | undefined;

package/dist/runtime/helper/array/random.js

@@ -0,0 +1,19 @@
+export function random(array, count) {
+  if (array.length === 0) {
+    return count ? [] : void 0;
+  }
+  if (count === void 0) {
+    const index = Math.floor(Math.random() * array.length);
+    return array[index];
+  }
+  if (count < 0 || count > array.length) {
+    throw new Error("The number of items to pick must be between 0 and the array length.");
+  }
+  const copy = [...array];
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    const index = Math.floor(Math.random() * copy.length);
+    result.push(copy.splice(index, 1)[0]);
+  }
+  return result;
+}

package/dist/runtime/helper/array/reject.d.ts

@@ -0,0 +1 @@
+export declare function reject<T>(array: T[], predicate: (item: T, index: number) => boolean): T[];

package/dist/runtime/helper/array/reject.js

@@ -0,0 +1,3 @@
+export function reject(array, predicate) {
+  return array.filter((item, index) => !predicate(item, index));
+}

package/dist/runtime/helper/array/shuffle.d.ts

@@ -0,0 +1 @@
+export declare function shuffle<T>(array: T[]): T[];

package/dist/runtime/helper/array/shuffle.js

@@ -0,0 +1,8 @@
+export function shuffle(array) {
+  const copy = [...array];
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy;
+}

package/dist/runtime/helper/array/sole.d.ts

@@ -0,0 +1 @@
+export declare function sole<T>(array: T[], predicate?: (item: T, index: number) => boolean): T;

package/dist/runtime/helper/array/sole.js

@@ -0,0 +1,7 @@
+export function sole(array, predicate) {
+  const matches = predicate ? array.filter(predicate) : [...array];
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  throw new Error(matches.length === 0 ? "Item not found." : "More than one item found.");
+}

package/dist/runtime/helper/array/some.d.ts

@@ -0,0 +1 @@
+export declare function some<T>(array: T[], predicate: (item: T, index: number) => boolean): boolean;

package/dist/runtime/helper/array/some.js

@@ -0,0 +1,3 @@
+export function some(array, predicate) {
+  return array.some(predicate);
+}

package/dist/runtime/helper/array/sort.d.ts

@@ -0,0 +1 @@
+export declare function sort<T>(array: T[], comparator?: (a: T, b: T) => number): T[];

package/dist/runtime/helper/array/sort.js

@@ -0,0 +1,4 @@
+export function sort(array, comparator) {
+  const copy = [...array];
+  return copy.sort(comparator);
+}

package/dist/runtime/helper/array/sortDesc.d.ts

@@ -0,0 +1 @@
+export declare function sortDesc<T>(array: T[], comparator?: (a: T, b: T) => number): T[];

package/dist/runtime/helper/array/sortDesc.js

@@ -0,0 +1,9 @@
+export function sortDesc(array, comparator) {
+  const copy = [...array];
+  return copy.sort((a, b) => {
+    if (comparator) {
+      return comparator(b, a);
+    }
+    return a < b ? 1 : a > b ? -1 : 0;
+  });
+}

package/dist/runtime/helper/array/take.d.ts

@@ -0,0 +1 @@
+export declare function take<T>(array: T[], limit: number): T[];

package/dist/runtime/helper/array/take.js

@@ -0,0 +1,9 @@
+export function take(array, limit) {
+  if (limit === 0) {
+    return [];
+  }
+  if (limit > 0) {
+    return array.slice(0, limit);
+  }
+  return array.slice(limit);
+}

package/dist/runtime/helper/array/where.d.ts

@@ -0,0 +1 @@
+export declare function where<T>(array: T[], predicate: (item: T, index: number) => boolean): T[];

package/dist/runtime/helper/array/where.js

@@ -0,0 +1,3 @@
+export function where(array, predicate) {
+  return array.filter(predicate);
+}

package/dist/runtime/helper/array/whereNotNull.d.ts

@@ -0,0 +1 @@
+export declare function whereNotNull<T>(array: T[]): (T & {})[];

package/dist/runtime/helper/array/whereNotNull.js

@@ -0,0 +1,3 @@
+export function whereNotNull(array) {
+  return array.filter((item) => item !== null && item !== void 0);
+}

package/dist/runtime/helper/array/wrap.d.ts

@@ -0,0 +1 @@
+export declare function wrap<T>(value: T | T[] | null | undefined): T[];

package/dist/runtime/helper/array/wrap.js

@@ -0,0 +1,6 @@
+export function wrap(value) {
+  if (value === null || value === void 0) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}

package/dist/runtime/helper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './array/index.js';
+export * from './object/index.js';
+export * from './number/index.js';
+export * from './string/index.js';

package/dist/runtime/helper/index.js

@@ -0,0 +1,4 @@
+export * from "./array/index.js";
+export * from "./object/index.js";
+export * from "./number/index.js";
+export * from "./string/index.js";

package/dist/runtime/helper/number/clamp.d.ts

@@ -0,0 +1 @@
+export declare function clamp(number: number, min: number, max: number): number;

package/dist/runtime/helper/number/clamp.js

@@ -0,0 +1,3 @@
+export function clamp(number, min, max) {
+  return Math.min(Math.max(number, min), max);
+}

package/dist/runtime/helper/number/currency.d.ts

@@ -0,0 +1 @@
+export declare function currency(number: number, inCurrency?: string, locale?: string | null, precision?: number | null): string;

package/dist/runtime/helper/number/currency.js

@@ -0,0 +1,14 @@
+import { defaultCurrency, defaultLocale } from "./state.js";
+export function currency(number, inCurrency = "", locale, precision) {
+  const resolvedLocale = locale ?? defaultLocale();
+  const resolvedCurrency = inCurrency || defaultCurrency();
+  const options = {
+    style: "currency",
+    currency: resolvedCurrency
+  };
+  if (precision !== null && precision !== void 0) {
+    options.minimumFractionDigits = precision;
+    options.maximumFractionDigits = precision;
+  }
+  return new Intl.NumberFormat(resolvedLocale, options).format(number);
+}

package/dist/runtime/helper/number/fileSize.d.ts

@@ -0,0 +1 @@
+export declare function fileSize(bytes: number, precision?: number, maxPrecision?: number | null): string;

package/dist/runtime/helper/number/fileSize.js

@@ -0,0 +1,12 @@
+import { format } from "./format.js";
+export function fileSize(bytes, precision = 0, maxPrecision) {
+  const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const unitCount = units.length;
+  let size = bytes;
+  let unitIndex = 0;
+  while (size / 1024 > 0.9 && unitIndex < unitCount - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${format(size, precision, maxPrecision)} ${units[unitIndex]}`;
+}

package/dist/runtime/helper/number/format.d.ts

@@ -0,0 +1 @@
+export declare function format(number: number, precision?: number | null, maxPrecision?: number | null, locale?: string | null): string;

package/dist/runtime/helper/number/format.js

@@ -0,0 +1,12 @@
+import { defaultLocale } from "./state.js";
+export function format(number, precision, maxPrecision, locale) {
+  const resolvedLocale = locale ?? defaultLocale();
+  const options = {};
+  if (maxPrecision !== null && maxPrecision !== void 0) {
+    options.maximumFractionDigits = maxPrecision;
+  } else if (precision !== null && precision !== void 0) {
+    options.minimumFractionDigits = precision;
+    options.maximumFractionDigits = precision;
+  }
+  return new Intl.NumberFormat(resolvedLocale, options).format(number);
+}

package/dist/runtime/helper/number/humanize.d.ts

@@ -0,0 +1,5 @@
+type UnitMap = Record<number, string>;
+export declare function abbreviate(number: number, precision?: number, maxPrecision?: number | null): any;
+export declare function forHumans(number: number, precision?: number, maxPrecision?: number | null): any;
+export declare function summarize(number: number, precision?: number, maxPrecision?: number | null, units?: UnitMap): any;
+export {};

package/dist/runtime/helper/number/humanize.js

@@ -0,0 +1,39 @@
+import { format } from "./format.js";
+const abbreviatedUnits = {
+  3: "K",
+  6: "M",
+  9: "B",
+  12: "T",
+  15: "Q"
+};
+const verboseUnits = {
+  3: " thousand",
+  6: " million",
+  9: " billion",
+  12: " trillion",
+  15: " quadrillion"
+};
+export function abbreviate(number, precision = 0, maxPrecision) {
+  return summarize(number, precision, maxPrecision, abbreviatedUnits);
+}
+export function forHumans(number, precision = 0, maxPrecision) {
+  return summarize(number, precision, maxPrecision, verboseUnits);
+}
+export function summarize(number, precision = 0, maxPrecision, units = abbreviatedUnits) {
+  if (number === 0) {
+    return precision > 0 ? format(0, precision, maxPrecision) : "0";
+  }
+  if (number < 0) {
+    return `-${summarize(Math.abs(number), precision, maxPrecision, units)}`;
+  }
+  if (number < 1) {
+    return format(number, precision, maxPrecision);
+  }
+  if (number >= 1e15) {
+    return `${summarize(number / 1e15, precision, maxPrecision, units)}${units[15] ?? ""}`;
+  }
+  const exponent = Math.floor(Math.log10(number));
+  const displayExponent = exponent - exponent % 3;
+  const scaledNumber = number / Math.pow(10, displayExponent);
+  return `${format(scaledNumber, precision, maxPrecision)}${units[displayExponent] ?? ""}`.trim();
+}

package/dist/runtime/helper/number/index.d.ts

@@ -0,0 +1,37 @@
+import { abbreviate, forHumans } from './humanize.js';
+import { clamp } from './clamp.js';
+import { currency } from './currency.js';
+import { defaultCurrency, defaultLocale, useCurrency, useLocale, withCurrency, withLocale } from './state.js';
+import { fileSize } from './fileSize.js';
+import { format } from './format.js';
+import { ordinal } from './ordinal.js';
+import { pairs } from './pairs.js';
+import { parse, parseFloatNumber, parseIntNumber } from './parse.js';
+import { percentage } from './percentage.js';
+import { spell, spellOrdinal } from './spell.js';
+import { trim } from './trim.js';
+export interface NumberHelper {
+    abbreviate: typeof abbreviate;
+    forHumans: typeof forHumans;
+    clamp: typeof clamp;
+    currency: typeof currency;
+    defaultCurrency: typeof defaultCurrency;
+    defaultLocale: typeof defaultLocale;
+    fileSize: typeof fileSize;
+    format: typeof format;
+    ordinal: typeof ordinal;
+    pairs: typeof pairs;
+    parse: typeof parse;
+    parseFloatNumber: typeof parseFloatNumber;
+    parseIntNumber: typeof parseIntNumber;
+    percentage: typeof percentage;
+    spell: typeof spell;
+    spellOrdinal: typeof spellOrdinal;
+    trim: typeof trim;
+    useLocale: typeof useLocale;
+    withLocale: typeof withLocale;
+    useCurrency: typeof useCurrency;
+    withCurrency: typeof withCurrency;
+}
+export declare function number(): NumberHelper;
+export { abbreviate, forHumans, clamp, currency, defaultCurrency, defaultLocale, fileSize, format, ordinal, pairs, parse, parseFloatNumber, parseIntNumber, percentage, spell, spellOrdinal, trim, useLocale, withLocale, useCurrency, withCurrency, };

package/dist/runtime/helper/number/index.js

@@ -0,0 +1,60 @@
+import { abbreviate, forHumans } from "./humanize.js";
+import { clamp } from "./clamp.js";
+import { currency } from "./currency.js";
+import { defaultCurrency, defaultLocale, useCurrency, useLocale, withCurrency, withLocale } from "./state.js";
+import { fileSize } from "./fileSize.js";
+import { format } from "./format.js";
+import { ordinal } from "./ordinal.js";
+import { pairs } from "./pairs.js";
+import { parse, parseFloatNumber, parseIntNumber } from "./parse.js";
+import { percentage } from "./percentage.js";
+import { spell, spellOrdinal } from "./spell.js";
+import { trim } from "./trim.js";
+export function number() {
+  return {
+    abbreviate,
+    forHumans,
+    clamp,
+    currency,
+    defaultCurrency,
+    defaultLocale,
+    fileSize,
+    format,
+    ordinal,
+    pairs,
+    parse,
+    parseFloatNumber,
+    parseIntNumber,
+    percentage,
+    spell,
+    spellOrdinal,
+    trim,
+    useLocale,
+    withLocale,
+    useCurrency,
+    withCurrency
+  };
+}
+export {
+  abbreviate,
+  forHumans,
+  clamp,
+  currency,
+  defaultCurrency,
+  defaultLocale,
+  fileSize,
+  format,
+  ordinal,
+  pairs,
+  parse,
+  parseFloatNumber,
+  parseIntNumber,
+  percentage,
+  spell,
+  spellOrdinal,
+  trim,
+  useLocale,
+  withLocale,
+  useCurrency,
+  withCurrency
+};

package/dist/runtime/helper/number/intl.d.ts

@@ -0,0 +1,5 @@
+export declare function getNumberSymbols(locale?: string): {
+    group: string;
+    decimal: string;
+};
+export declare function normalizeNumberString(value: string, locale?: string): string | null;

package/dist/runtime/helper/number/intl.js

@@ -0,0 +1,32 @@
+import { defaultLocale } from "./state.js";
+const numberSymbolsCache = /* @__PURE__ */ new Map();
+function extractNumberSymbols(locale) {
+  const formatter = new Intl.NumberFormat(locale);
+  const parts = formatter.formatToParts(12345.6);
+  const group = parts.find((part) => part.type === "group")?.value ?? ",";
+  const decimal = parts.find((part) => part.type === "decimal")?.value ?? ".";
+  return { group, decimal };
+}
+export function getNumberSymbols(locale) {
+  const resolvedLocale = locale ?? defaultLocale();
+  if (!numberSymbolsCache.has(resolvedLocale)) {
+    numberSymbolsCache.set(resolvedLocale, extractNumberSymbols(resolvedLocale));
+  }
+  return numberSymbolsCache.get(resolvedLocale);
+}
+export function normalizeNumberString(value, locale) {
+  if (!value) {
+    return null;
+  }
+  const { group, decimal } = getNumberSymbols(locale);
+  const escapedGroup = escapeRegExp(group);
+  const escapedDecimal = escapeRegExp(decimal);
+  const sanitized = value.replace(/\s+/g, "").replace(/\u00A0/g, "").replace(new RegExp(escapedGroup, "g"), "").replace(new RegExp(escapedDecimal, "g"), ".").replace(/[^0-9+.-]/g, "");
+  if (!sanitized || sanitized === "." || sanitized === "+" || sanitized === "-") {
+    return null;
+  }
+  return sanitized;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/runtime/helper/number/ordinal.d.ts

@@ -0,0 +1 @@
+export declare function ordinal(number: number, locale?: string | null): string;

package/dist/runtime/helper/number/ordinal.js

@@ -0,0 +1,26 @@
+import { defaultLocale } from "./state.js";
+const ordinalRulesCache = /* @__PURE__ */ new Map();
+function getOrdinalRules(locale) {
+  if (!ordinalRulesCache.has(locale)) {
+    ordinalRulesCache.set(locale, new Intl.PluralRules(locale, { type: "ordinal" }));
+  }
+  return ordinalRulesCache.get(locale);
+}
+function ordinalSuffix(number, locale) {
+  const rule = getOrdinalRules(locale);
+  const category = rule.select(number);
+  switch (category) {
+    case "one":
+      return "st";
+    case "two":
+      return "nd";
+    case "few":
+      return "rd";
+    default:
+      return "th";
+  }
+}
+export function ordinal(number, locale) {
+  const resolvedLocale = locale ?? defaultLocale();
+  return `${number}${ordinalSuffix(number, resolvedLocale)}`;
+}

package/dist/runtime/helper/number/pairs.d.ts

@@ -0,0 +1 @@
+export declare function pairs(to: number, by: number, start?: number, offset?: number): [number, number][];

package/dist/runtime/helper/number/pairs.js

@@ -0,0 +1,11 @@
+export function pairs(to, by, start = 0, offset = 1) {
+  const output = [];
+  for (let lower = start; lower < to; lower += by) {
+    let upper = lower + by - offset;
+    if (upper > to) {
+      upper = to;
+    }
+    output.push([lower, upper]);
+  }
+  return output;
+}

package/dist/runtime/helper/number/parse.d.ts

@@ -0,0 +1,4 @@
+export type ParseType = 'float' | 'int';
+export declare function parse(value: string, type?: ParseType, locale?: string): number | false;
+export declare function parseIntNumber(value: string, locale?: string): number | false;
+export declare function parseFloatNumber(value: string, locale?: string): number | false;

package/dist/runtime/helper/number/parse.js

@@ -0,0 +1,19 @@
+import { defaultLocale } from "./state.js";
+import { normalizeNumberString } from "./intl.js";
+export function parse(value, type = "float", locale) {
+  const normalized = normalizeNumberString(value, locale ?? defaultLocale());
+  if (normalized === null) {
+    return false;
+  }
+  const result = type === "int" ? Number.parseInt(normalized, 10) : Number.parseFloat(normalized);
+  if (Number.isNaN(result)) {
+    return false;
+  }
+  return result;
+}
+export function parseIntNumber(value, locale) {
+  return parse(value, "int", locale);
+}
+export function parseFloatNumber(value, locale) {
+  return parse(value, "float", locale);
+}

package/dist/runtime/helper/number/percentage.d.ts

@@ -0,0 +1 @@
+export declare function percentage(number: number, precision?: number, maxPrecision?: number | null, locale?: string | null): string;