@ciwergrp/nuxid 1.0.2-release

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

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

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

@@ -0,0 +1,2 @@
+export declare function spell(number: number, locale?: string | null, after?: number | null, until?: number | null): string;
+export declare function spellOrdinal(number: number, locale?: string | null): string;

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

@@ -0,0 +1,145 @@
+import { defaultLocale } from "./state.js";
+import { format } from "./format.js";
+const belowTwenty = [
+  "zero",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+const tens = [
+  "",
+  "",
+  "twenty",
+  "thirty",
+  "forty",
+  "fifty",
+  "sixty",
+  "seventy",
+  "eighty",
+  "ninety"
+];
+const scales = ["", "thousand", "million", "billion", "trillion", "quadrillion"];
+export function spell(number, locale, after, until) {
+  if (after !== null && after !== void 0 && number <= after) {
+    return format(number, void 0, void 0, locale ?? defaultLocale());
+  }
+  if (until !== null && until !== void 0 && number >= until) {
+    return format(number, void 0, void 0, locale ?? defaultLocale());
+  }
+  return numberToWords(number, locale ?? defaultLocale());
+}
+export function spellOrdinal(number, locale) {
+  const resolvedLocale = locale ?? defaultLocale();
+  const cardinal = numberToWords(number, resolvedLocale);
+  return convertToOrdinalWords(cardinal);
+}
+function numberToWords(value, _locale) {
+  const isNegative = value < 0;
+  const absolute = Math.abs(value);
+  const [integerPart, fractionPart] = absolute.toString().split(".");
+  const integerWords = integerToWords(Number.parseInt(integerPart, 10));
+  const fractionWords = fractionPart ? fractionPart.split("").map((digit) => belowTwenty[Number(digit)]) : [];
+  let words = integerWords;
+  if (fractionWords.length) {
+    words = `${integerWords} point ${fractionWords.join(" ")}`;
+  }
+  if (isNegative) {
+    words = `negative ${words}`;
+  }
+  return words;
+}
+function integerToWords(value) {
+  if (value === 0) {
+    return belowTwenty[0];
+  }
+  const chunks = [];
+  let remaining = value;
+  while (remaining > 0) {
+    chunks.push(remaining % 1e3);
+    remaining = Math.floor(remaining / 1e3);
+  }
+  const words = [];
+  for (let index = 0; index < chunks.length; index++) {
+    const chunk = chunks[index];
+    if (chunk === 0) {
+      continue;
+    }
+    const chunkWords = chunkToWords(chunk);
+    const scale = scales[index];
+    words.unshift(scale ? `${chunkWords} ${scale}` : chunkWords);
+  }
+  return words.join(" ");
+}
+function chunkToWords(value) {
+  const words = [];
+  const hundreds = Math.floor(value / 100);
+  const remainder = value % 100;
+  if (hundreds > 0) {
+    words.push(`${belowTwenty[hundreds]} hundred`);
+  }
+  if (remainder > 0) {
+    if (remainder < 20) {
+      words.push(belowTwenty[remainder]);
+    } else {
+      const tensPlace = Math.floor(remainder / 10);
+      const unitsPlace = remainder % 10;
+      if (tens[tensPlace]) {
+        words.push(unitsPlace ? `${tens[tensPlace]}-${belowTwenty[unitsPlace]}` : tens[tensPlace]);
+      }
+    }
+  }
+  return words.join(" ");
+}
+function convertToOrdinalWords(value) {
+  const parts = value.split(" ");
+  if (!parts.length) {
+    return value;
+  }
+  const last = parts.pop();
+  const hyphenParts = last.split("-");
+  const lastToken = hyphenParts.pop();
+  const ordinal = toOrdinalWord(lastToken);
+  const rebuiltLast = hyphenParts.length ? [...hyphenParts, ordinal].join("-") : ordinal;
+  return [...parts, rebuiltLast].join(" ");
+}
+function toOrdinalWord(word) {
+  const normalized = word.toLowerCase();
+  const irregular = {
+    one: "first",
+    two: "second",
+    three: "third",
+    five: "fifth",
+    eight: "eighth",
+    nine: "ninth",
+    twelve: "twelfth"
+  };
+  if (irregular[normalized]) {
+    return irregular[normalized];
+  }
+  if (normalized.endsWith("y")) {
+    return `${normalized.slice(0, -1)}ieth`;
+  }
+  if (normalized.endsWith("ve")) {
+    return `${normalized.slice(0, -2)}fth`;
+  }
+  if (normalized.endsWith("ht")) {
+    return `${normalized}h`;
+  }
+  return `${normalized}th`;
+}

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

@@ -0,0 +1 @@
+export { defaultCurrency, defaultLocale, useCurrency, useLocale, withCurrency, withLocale, } from '../state.js';

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

@@ -0,0 +1,8 @@
+export {
+  defaultCurrency,
+  defaultLocale,
+  useCurrency,
+  useLocale,
+  withCurrency,
+  withLocale
+} from "../state.js";

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

@@ -0,0 +1 @@
+export declare function trim(number: number): number;

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

@@ -0,0 +1,3 @@
+export function trim(number) {
+  return Number.parseFloat(Number(number).toString());
+}

package/dist/runtime/helper/object/add.d.ts

@@ -0,0 +1,2 @@
+import type { Path } from './utils.js';
+export declare function add<T extends Record<string, any>>(target: T, path: Path, value: any): T;

package/dist/runtime/helper/object/add.js

@@ -0,0 +1,8 @@
+import { get } from "./get.js";
+import { set } from "./set.js";
+export function add(target, path, value) {
+  if (get(target, path) === void 0 || get(target, path) === null) {
+    set(target, path, value);
+  }
+  return target;
+}

package/dist/runtime/helper/object/dot.d.ts

@@ -0,0 +1 @@
+export declare function dot(target: Record<string, any>, prefix?: string): Record<string, any>;

package/dist/runtime/helper/object/dot.js

@@ -0,0 +1,19 @@
+import { isObject } from "./utils.js";
+export function dot(target, prefix = "") {
+  const result = {};
+  const handle = (value, currentPrefix) => {
+    if (isObject(value)) {
+      for (const [key, nested] of Object.entries(value)) {
+        const nextPrefix = currentPrefix ? `${currentPrefix}.${key}` : key;
+        handle(nested, nextPrefix);
+      }
+      return;
+    }
+    result[currentPrefix] = value;
+  };
+  for (const [key, value] of Object.entries(target)) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    handle(value, nextPrefix);
+  }
+  return result;
+}

package/dist/runtime/helper/object/except.d.ts

@@ -0,0 +1,2 @@
+import type { Path } from './utils.js';
+export declare function except(target: Record<string, any>, keys: Path | Path[]): Record<string, any>;

package/dist/runtime/helper/object/except.js

@@ -0,0 +1,10 @@
+export function except(target, keys) {
+  const exclusion = new Set((Array.isArray(keys) ? keys : [keys]).map((key) => String(key)));
+  const result = {};
+  for (const [k, v] of Object.entries(target)) {
+    if (!exclusion.has(k)) {
+      result[k] = v;
+    }
+  }
+  return result;
+}

package/dist/runtime/helper/object/forget.d.ts

@@ -0,0 +1,2 @@
+import { type Path } from './utils.js';
+export declare function forget(target: any, paths: Path | Path[]): any;

package/dist/runtime/helper/object/forget.js

@@ -0,0 +1,24 @@
+import { toPathArray } from "./utils.js";
+export function forget(target, paths) {
+  const list = Array.isArray(paths) ? paths : [paths];
+  for (const path of list) {
+    const segments = toPathArray(path);
+    let current = target;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (current == null || !(segment in current)) {
+        break;
+      }
+      if (i === segments.length - 1) {
+        if (Array.isArray(current)) {
+          current.splice(Number(segment), 1);
+        } else {
+          Reflect.deleteProperty(current, segment);
+        }
+      } else {
+        current = current[segment];
+      }
+    }
+  }
+  return target;
+}

package/dist/runtime/helper/object/get.d.ts

@@ -0,0 +1,2 @@
+import { type Path } from './utils.js';
+export declare function get<T = any>(value: any, path: Path, defaultValue?: T): T | undefined;

package/dist/runtime/helper/object/get.js

@@ -0,0 +1,15 @@
+import { isObject, toPathArray } from "./utils.js";
+export function get(value, path, defaultValue) {
+  const segments = toPathArray(path);
+  let current = value;
+  for (const segment of segments) {
+    if (isObject(current) || Array.isArray(current)) {
+      if (segment in current) {
+        current = current[segment];
+        continue;
+      }
+    }
+    return defaultValue;
+  }
+  return current ?? defaultValue;
+}

package/dist/runtime/helper/object/has.d.ts

@@ -0,0 +1,2 @@
+import type { Path } from './utils.js';
+export declare function has(target: any, paths: Path | Path[]): boolean;

package/dist/runtime/helper/object/has.js

@@ -0,0 +1,5 @@
+import { get } from "./get.js";
+export function has(target, paths) {
+  const list = Array.isArray(paths) ? paths : [paths];
+  return list.every((path) => get(target, path) !== void 0);
+}

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

@@ -0,0 +1,22 @@
+import { add } from './add.js';
+import { dot } from './dot.js';
+import { except } from './except.js';
+import { forget } from './forget.js';
+import { get } from './get.js';
+import { has } from './has.js';
+import { only } from './only.js';
+import { set } from './set.js';
+import { undot } from './undot.js';
+export interface ObjectHelper {
+    add: typeof add;
+    dot: typeof dot;
+    except: typeof except;
+    forget: typeof forget;
+    get: typeof get;
+    has: typeof has;
+    only: typeof only;
+    set: typeof set;
+    undot: typeof undot;
+}
+export declare function object(): ObjectHelper;
+export { add, dot, except, forget, get, has, only, set, undot, };

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

@@ -0,0 +1,33 @@
+import { add } from "./add.js";
+import { dot } from "./dot.js";
+import { except } from "./except.js";
+import { forget } from "./forget.js";
+import { get } from "./get.js";
+import { has } from "./has.js";
+import { only } from "./only.js";
+import { set } from "./set.js";
+import { undot } from "./undot.js";
+export function object() {
+  return {
+    add,
+    dot,
+    except,
+    forget,
+    get,
+    has,
+    only,
+    set,
+    undot
+  };
+}
+export {
+  add,
+  dot,
+  except,
+  forget,
+  get,
+  has,
+  only,
+  set,
+  undot
+};

package/dist/runtime/helper/object/only.d.ts

@@ -0,0 +1,2 @@
+import type { Path } from './utils.js';
+export declare function only(target: Record<string, any>, keys: Path | Path[]): Record<string, any>;

package/dist/runtime/helper/object/only.js

@@ -0,0 +1,12 @@
+import { get } from "./get.js";
+export function only(target, keys) {
+  const result = {};
+  const list = Array.isArray(keys) ? keys : [keys];
+  for (const key of list) {
+    const value = get(target, key);
+    if (value !== void 0) {
+      result[String(key)] = value;
+    }
+  }
+  return result;
+}

package/dist/runtime/helper/object/set.d.ts

@@ -0,0 +1,2 @@
+import { type Path } from './utils.js';
+export declare function set<T extends Record<string, any>>(target: T, path: Path, value: any): T;

package/dist/runtime/helper/object/set.js

@@ -0,0 +1,23 @@
+import { isObject, toPathArray } from "./utils.js";
+export function set(target, path, value) {
+  const segments = toPathArray(path);
+  if (segments.length === 0) {
+    return target;
+  }
+  let current = target;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+    if (isLast) {
+      current[segment] = value;
+    } else {
+      const next = current[segment];
+      if (!isObject(next) && !Array.isArray(next)) {
+        const nextSegment = segments[i + 1];
+        current[segment] = typeof nextSegment === "number" ? [] : {};
+      }
+      current = current[segment];
+    }
+  }
+  return target;
+}

package/dist/runtime/helper/object/undot.d.ts

@@ -0,0 +1 @@
+export declare function undot(target: Record<string, any>): Record<string, any>;

package/dist/runtime/helper/object/undot.js

@@ -0,0 +1,8 @@
+import { set } from "./set.js";
+export function undot(target) {
+  const result = {};
+  for (const [key, value] of Object.entries(target)) {
+    set(result, key, value);
+  }
+  return result;
+}

package/dist/runtime/helper/object/utils.d.ts

@@ -0,0 +1,3 @@
+export type Path = string | number | Array<string | number>;
+export declare function toPathArray(path: Path): Array<string | number>;
+export declare function isObject(value: unknown): value is Record<string, any>;

package/dist/runtime/helper/object/utils.js

@@ -0,0 +1,10 @@
+export function toPathArray(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  const value = String(path);
+  return value.split(".").map((segment) => segment.match(/^\d+$/) ? Number(segment) : segment);
+}
+export function isObject(value) {
+  return value !== null && typeof value === "object";
+}

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

@@ -0,0 +1,6 @@
+export declare function useLocale(locale: string): void;
+export declare function useCurrency(currency: string): void;
+export declare function defaultLocale(): string;
+export declare function defaultCurrency(): string;
+export declare function withLocale<T>(locale: string, callback: () => T | Promise<T>): T | Promise<T>;
+export declare function withCurrency<T>(currency: string, callback: () => T | Promise<T>): T | Promise<T>;

package/dist/runtime/helper/state.js

@@ -0,0 +1,50 @@
+let currentLocale = "en";
+let currentCurrency = "USD";
+export function useLocale(locale) {
+  currentLocale = locale;
+}
+export function useCurrency(currency) {
+  currentCurrency = currency;
+}
+export function defaultLocale() {
+  return currentLocale;
+}
+export function defaultCurrency() {
+  return currentCurrency;
+}
+export function withLocale(locale, callback) {
+  const previousLocale = currentLocale;
+  useLocale(locale);
+  let result;
+  try {
+    result = callback();
+  } finally {
+    if (!(result instanceof Promise)) {
+      useLocale(previousLocale);
+    }
+  }
+  if (result instanceof Promise) {
+    return result.finally(() => {
+      useLocale(previousLocale);
+    });
+  }
+  return result;
+}
+export function withCurrency(currency, callback) {
+  const previousCurrency = currentCurrency;
+  useCurrency(currency);
+  let result;
+  try {
+    result = callback();
+  } finally {
+    if (!(result instanceof Promise)) {
+      useCurrency(previousCurrency);
+    }
+  }
+  if (result instanceof Promise) {
+    return result.finally(() => {
+      useCurrency(previousCurrency);
+    });
+  }
+  return result;
+}

package/dist/runtime/helper/string/basic.d.ts

@@ -0,0 +1,7 @@
+export declare function length(value: string): number;
+export declare function trim(value: string, mask?: string): string;
+export declare function ltrim(value: string, mask?: string): string;
+export declare function rtrim(value: string, mask?: string): string;
+export declare function start(value: string, prefix: string): string;
+export declare function finish(value: string, suffix: string): string;
+export declare function wrap(value: string, before: string, after?: string): string;

package/dist/runtime/helper/string/basic.js

@@ -0,0 +1,42 @@
+export function length(value) {
+  return Array.from(value).length;
+}
+export function trim(value, mask) {
+  if (!mask) {
+    return value.trim();
+  }
+  const pattern = new RegExp(`^[${escapeMask(mask)}]+|[${escapeMask(mask)}]+$`, "g");
+  return value.replace(pattern, "");
+}
+export function ltrim(value, mask) {
+  if (!mask) {
+    return value.trimStart();
+  }
+  const pattern = new RegExp(`^[${escapeMask(mask)}]+`, "g");
+  return value.replace(pattern, "");
+}
+export function rtrim(value, mask) {
+  if (!mask) {
+    return value.trimEnd();
+  }
+  const pattern = new RegExp(`[${escapeMask(mask)}]+$`, "g");
+  return value.replace(pattern, "");
+}
+export function start(value, prefix) {
+  if (value.startsWith(prefix)) {
+    return value;
+  }
+  return `${prefix}${value}`;
+}
+export function finish(value, suffix) {
+  if (value.endsWith(suffix)) {
+    return value;
+  }
+  return `${value}${suffix}`;
+}
+export function wrap(value, before, after = before) {
+  return `${before}${value}${after}`;
+}
+function escapeMask(mask) {
+  return mask.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}

package/dist/runtime/helper/string/bounds.d.ts

@@ -0,0 +1,6 @@
+export declare function after(value: string, search: string): string;
+export declare function afterLast(value: string, search: string): string;
+export declare function before(value: string, search: string): string;
+export declare function beforeLast(value: string, search: string): string;
+export declare function between(value: string, from: string, to: string): string;
+export declare function betweenFirst(value: string, from: string, to: string): string;

package/dist/runtime/helper/string/bounds.js

@@ -0,0 +1,42 @@
+export function after(value, search) {
+  if (!search) {
+    return value;
+  }
+  const index = value.indexOf(search);
+  return index === -1 ? value : value.slice(index + search.length);
+}
+export function afterLast(value, search) {
+  if (!search) {
+    return value;
+  }
+  const index = value.lastIndexOf(search);
+  return index === -1 ? value : value.slice(index + search.length);
+}
+export function before(value, search) {
+  if (!search) {
+    return value;
+  }
+  const index = value.indexOf(search);
+  return index === -1 ? value : value.slice(0, index);
+}
+export function beforeLast(value, search) {
+  if (!search) {
+    return value;
+  }
+  const index = value.lastIndexOf(search);
+  return index === -1 ? value : value.slice(0, index);
+}
+export function between(value, from, to) {
+  return before(after(value, from), to);
+}
+export function betweenFirst(value, from, to) {
+  const start = value.indexOf(from);
+  if (start === -1) {
+    return "";
+  }
+  const end = value.indexOf(to, start + from.length);
+  if (end === -1) {
+    return "";
+  }
+  return value.slice(start + from.length, end);
+}

package/dist/runtime/helper/string/case.d.ts

@@ -0,0 +1,9 @@
+export declare function camel(value: string): string;
+export declare function studly(value: string): string;
+export declare function kebab(value: string): string;
+export declare function snake(value: string): string;
+export declare function title(value: string): string;
+export declare function upper(value: string): string;
+export declare function lower(value: string): string;
+export declare function ucfirst(value: string): string;
+export declare function lcfirst(value: string): string;

package/dist/runtime/helper/string/case.js

@@ -0,0 +1,50 @@
+const WORD_SEPARATOR = /[\s_.-]+/;
+function toWords(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(WORD_SEPARATOR).filter(Boolean);
+}
+export function camel(value) {
+  const parts = toWords(value.toLowerCase());
+  if (!parts.length) {
+    return "";
+  }
+  return parts.map(
+    (part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+  ).join("");
+}
+export function studly(value) {
+  const parts = toWords(value.toLowerCase());
+  return parts.map(capitalize).join("");
+}
+export function kebab(value) {
+  return toWords(value.toLowerCase()).join("-");
+}
+export function snake(value) {
+  return toWords(value.toLowerCase()).join("_");
+}
+export function title(value) {
+  return toWords(value).map(capitalize).join(" ");
+}
+export function upper(value) {
+  return value.toUpperCase();
+}
+export function lower(value) {
+  return value.toLowerCase();
+}
+export function ucfirst(value) {
+  if (!value) {
+    return "";
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+export function lcfirst(value) {
+  if (!value) {
+    return "";
+  }
+  return value.charAt(0).toLowerCase() + value.slice(1);
+}
+function capitalize(value) {
+  if (!value) {
+    return "";
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}