@regardio/js 0.6.0 → 0.7.0

package/dist/http/index.js

@@ -1,126 +0,0 @@
-// src/http/cookie.ts
-function setCookieValue(name, value, options = {}) {
-  if (typeof window === "undefined") {
-    console.warn("Cannot set cookie on server side");
-    return;
-  }
-  let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (options.expires) {
-    cookieString += `; expires=${options.expires.toUTCString()}`;
-  }
-  if (options.path) {
-    cookieString += `; path=${options.path}`;
-  }
-  if (options.sameSite) {
-    cookieString += `; SameSite=${options.sameSite}`;
-  }
-  if (options.secure) {
-    cookieString += "; Secure";
-  }
-  if (options.domain) {
-    cookieString += `; domain=${options.domain}`;
-  }
-  try {
-    document.cookie = cookieString;
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(`Failed to set cookie '${name}':`, error.message);
-    } else {
-      console.error(`Failed to set cookie '${name}': Unknown error`);
-    }
-  }
-}
-function getCookieValue(name) {
-  if (typeof window === "undefined") {
-    console.warn("Cannot get cookie on server side");
-    return null;
-  }
-  const value = `; ${document.cookie}`;
-  const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) {
-    const cookieValue = parts.pop()?.split(";").shift();
-    return cookieValue ? decodeURIComponent(cookieValue) : null;
-  }
-  return null;
-}
-
-// src/http/domain.ts
-var createDomain = (request) => {
-  const headers = request.headers;
-  const maybeProto = headers.get("x-forwarded-proto");
-  const maybeHost = headers.get("host");
-  const url = new URL(request.url);
-  if (maybeProto) {
-    return `${maybeProto}://${maybeHost ?? url.host}`;
-  }
-  if (url.hostname === "localhost") {
-    return `http://${url.host}`;
-  }
-  return `https://${url.host}`;
-};
-
-// src/http/is-route-active.ts
-var ROOT_PATH = "/";
-function isRouteActive(path, currentPath, end) {
-  if (path === currentPath) {
-    return true;
-  }
-  if (typeof end === "function") {
-    return !end(currentPath);
-  }
-  const defaultEnd = end ?? true;
-  const oneLevelDeep = 1;
-  const threeLevelsDeep = 3;
-  const depth = defaultEnd ? oneLevelDeep : threeLevelsDeep;
-  return checkIfRouteIsActive(path, currentPath, depth);
-}
-function checkIfRouteIsActive(targetLink, currentRoute, depth = 1) {
-  const currentRoutePath = currentRoute.split("?")[0] ?? "";
-  if (!isRoot(currentRoutePath) && isRoot(targetLink)) {
-    return false;
-  }
-  if (!currentRoutePath.includes(targetLink)) {
-    return false;
-  }
-  const isSameRoute = targetLink === currentRoutePath;
-  if (isSameRoute) {
-    return true;
-  }
-  return hasMatchingSegments(targetLink, currentRoutePath, depth);
-}
-function splitIntoSegments(href) {
-  return href.split("/").filter(Boolean);
-}
-function hasMatchingSegments(targetLink, currentRoute, depth) {
-  const segments = splitIntoSegments(targetLink);
-  const matchingSegments = numberOfMatchingSegments(currentRoute, segments);
-  if (targetLink === currentRoute) {
-    return true;
-  }
-  return matchingSegments > segments.length - (depth - 1);
-}
-function numberOfMatchingSegments(href, segments) {
-  let count = 0;
-  for (const segment of splitIntoSegments(href)) {
-    if (segments.includes(segment)) {
-      count += 1;
-    } else {
-      return count;
-    }
-  }
-  return count;
-}
-function isRoot(path) {
-  return path === ROOT_PATH;
-}
-
-// src/http/request-helpers.ts
-function getCleanUrl(request) {
-  const url = new URL(request.url);
-  url.searchParams.forEach((_, key) => {
-    url.searchParams.delete(key);
-  });
-  return url.toString();
-}
-
-export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };

package/dist/intl/index.d.ts

@@ -1,91 +0,0 @@
-import { Cookie, SessionStorage } from 'react-router';
-
-interface LanguageDetectorOption {
-    /**
-     * Define the list of supported languages, this is used to determine if one of
-     * the languages requested by the user is supported by the application.
-     * This should be be same as the supportedLngs in the i18next options.
-     */
-    supportedLanguages: string[];
-    /**
-     * Define the fallback language that it's going to be used in the case user
-     * expected language is not supported.
-     * This should be be same as the fallbackLng in the i18next options.
-     */
-    fallbackLanguage: string;
-    /**
-     * If you want to use a cookie to store the user preferred language, you can
-     * pass the Cookie object here.
-     */
-    cookie?: Cookie;
-    /**
-     * If you want to use a session to store the user preferred language, you can
-     * pass the SessionStorage object here.
-     * When this is not defined, getting the locale will ignore the session.
-     */
-    sessionStorage?: SessionStorage;
-    /**
-     * If defined a sessionStorage and want to change the default key used to
-     * store the user preferred language, you can pass the key here.
-     * @default "lng"
-     */
-    sessionKey?: string;
-    /**
-     * If you want to use search parameters for language detection and want to
-     * change the default key used to for the parameter name,
-     * you can pass the key here.
-     * @default "lng"
-     */
-    searchParamKey?: string;
-    /**
-     * The order the library will use to detect the user preferred language.
-     * By default the order is
-     * - urlPath (first segment like /de/ or /en/)
-     * - cookie
-     * - session
-     * - searchParams
-     * - header
-     * And finally the fallback language.
-     */
-    order?: Array<'urlPath' | 'searchParams' | 'cookie' | 'session' | 'header'>;
-}
-interface LanguageDetectorLinguiOptions {
-    detection: LanguageDetectorOption;
-}
-declare class LanguageDetectorLingui {
-    private detector;
-    private options;
-    constructor(options: LanguageDetectorLinguiOptions);
-    /**
-     * Detect the current locale by following the order defined in the
-     * `detection.order` option.
-     * By default the order is
-     * - urlPath (first segment like /de/ or /en/)
-     * - cookie
-     * - session
-     * - searchParams
-     * - header
-     * And finally the fallback language.
-     */
-    getLocale(request: Request): Promise<string>;
-}
-/**
- * The LanguageDetector contains the logic to detect the user preferred language
- * fully server-side by using a SessionStorage, Cookie, URLSearchParams, or
- * Headers.
- */
-declare class LanguageDetector {
-    private options;
-    constructor(options: LanguageDetectorOption);
-    detect(request: Request): Promise<string>;
-    private isSessionOnly;
-    private isCookieOnly;
-    private fromUrlPath;
-    private fromSearchParams;
-    private fromCookie;
-    private fromSessionStorage;
-    private fromHeader;
-    private fromSupported;
-}
-
-export { LanguageDetector, LanguageDetectorLingui, type LanguageDetectorLinguiOptions, type LanguageDetectorOption };

package/dist/intl/index.js

@@ -1,139 +0,0 @@
-import { parseAcceptLanguage } from 'intl-parse-accept-language';
-
-// src/intl/language-detector.ts
-var LanguageDetectorLingui = class {
-  detector;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.detector = new LanguageDetector(this.options.detection);
-  }
-  /**
-   * Detect the current locale by following the order defined in the
-   * `detection.order` option.
-   * By default the order is
-   * - urlPath (first segment like /de/ or /en/)
-   * - cookie
-   * - session
-   * - searchParams
-   * - header
-   * And finally the fallback language.
-   */
-  async getLocale(request) {
-    return await this.detector.detect(request);
-  }
-};
-var LanguageDetector = class {
-  options;
-  constructor(options) {
-    this.options = options;
-    this.isSessionOnly(this.options);
-    this.isCookieOnly(this.options);
-  }
-  async detect(request) {
-    const order = this.options.order ?? ["urlPath", "cookie", "session", "searchParams", "header"];
-    for (const method of order) {
-      let locale = null;
-      if (method === "urlPath") {
-        locale = this.fromUrlPath(request);
-      }
-      if (method === "searchParams") {
-        locale = this.fromSearchParams(request);
-      }
-      if (method === "cookie") {
-        locale = await this.fromCookie(request);
-      }
-      if (method === "session") {
-        locale = await this.fromSessionStorage(request);
-      }
-      if (method === "header") {
-        locale = this.fromHeader(request);
-      }
-      if (locale) return locale;
-    }
-    return this.options.fallbackLanguage;
-  }
-  isSessionOnly(options) {
-    if (options.order?.length === 1 && options.order[0] === "session" && !options.sessionStorage) {
-      throw new Error(
-        "You need a sessionStorage if you want to only get the locale from the session"
-      );
-    }
-  }
-  isCookieOnly(options) {
-    if (options.order?.length === 1 && options.order[0] === "cookie" && !options.cookie) {
-      throw new Error("You need a cookie if you want to only get the locale from the cookie");
-    }
-  }
-  fromUrlPath(request) {
-    const url = new URL(request.url);
-    const pathSegments = url.pathname.split("/").filter(Boolean);
-    if (pathSegments.length > 0) {
-      const firstSegment = pathSegments[0];
-      if (firstSegment) {
-        return this.fromSupported(firstSegment);
-      }
-    }
-    return null;
-  }
-  fromSearchParams(request) {
-    const url = new URL(request.url);
-    if (!url.searchParams.has(this.options.searchParamKey ?? "lng")) {
-      return null;
-    }
-    return this.fromSupported(url.searchParams.get(this.options.searchParamKey ?? "lng"));
-  }
-  async fromCookie(request) {
-    if (!this.options.cookie) return null;
-    const cookie = this.options.cookie;
-    try {
-      const lng = await cookie.parse(request.headers.get("Cookie"));
-      if (typeof lng !== "string" || !lng) return null;
-      return this.fromSupported(lng);
-    } catch (_error) {
-      return null;
-    }
-  }
-  async fromSessionStorage(request) {
-    if (!this.options.sessionStorage) return null;
-    const session = await this.options.sessionStorage.getSession(request.headers.get("Cookie"));
-    const lng = session.get(this.options.sessionKey ?? "lng");
-    if (!lng) return null;
-    return this.fromSupported(lng);
-  }
-  fromHeader(request) {
-    const locales = getClientLocales(request);
-    if (!locales) return null;
-    if (Array.isArray(locales)) return this.fromSupported(locales.join(","));
-    return this.fromSupported(locales);
-  }
-  fromSupported(language) {
-    if (!language) return this.options.fallbackLanguage;
-    const languageStr = Array.isArray(language) ? language.join(",") : language;
-    const parsed = parseAcceptLanguage(languageStr, {
-      ignoreWildcard: true,
-      validate: (locale) => this.options.supportedLanguages.includes(locale) ? locale : null
-    });
-    return parsed[0] || this.options.fallbackLanguage;
-  }
-};
-function getClientLocales(requestOrHeaders) {
-  const headers = getHeaders(requestOrHeaders);
-  const acceptLanguage = headers.get("Accept-Language");
-  if (!acceptLanguage) return void 0;
-  const locales = parseAcceptLanguage(acceptLanguage, {
-    ignoreWildcard: true,
-    validate: Intl.DateTimeFormat.supportedLocalesOf
-  });
-  if (locales.length === 0) return void 0;
-  if (locales.length === 1) return locales[0];
-  return locales;
-}
-function getHeaders(requestOrHeaders) {
-  if (requestOrHeaders instanceof Request) {
-    return requestOrHeaders.headers;
-  }
-  return requestOrHeaders;
-}
-
-export { LanguageDetector, LanguageDetectorLingui };

package/dist/text/index.d.ts

@@ -1,46 +0,0 @@
-declare function formatBytes(bytes: number, decimals?: number): string;
-
-/**
- * Replace straight quotes with typographically correct quotes for the given locale.
- *
- * @param text - The text containing straight quotes
- * @param locale - The locale to use for quote style (e.g., 'en', 'de', 'fr')
- * @returns Text with typographic quotes
- *
- * @example
- * typographicQuotes('"Hello"', 'en') // → '"Hello"'
- * typographicQuotes('"Hello"', 'de') // → '„Hello"'
- * typographicQuotes('"Hello"', 'fr') // → '« Hello »'
- */
-declare function typographicQuotes(text: string, locale: string): string;
-declare function toBoolean(value: string | boolean | null | undefined): boolean;
-/**
- * Replace ­ HTML entity with Unicode soft hyphen
- */
-declare function replaceShyInString(input: string): string;
-/**
- * Split text into sentences
- */
-declare function splitIntoSentences(text: string): string[];
-/**
- * Split text into words
- */
-declare function splitIntoWords(text: string): string[];
-/**
- * Truncate text to a maximum length
- */
-declare function truncateText(text: string, maxLength: number, suffix?: string): string;
-/**
- * Author info parsed from a string like "Name <email> (url)"
- */
-type AuthorInfo = {
-    name?: string;
-    email?: string;
-    url?: string;
-};
-/**
- * Parse an author string in the format "Name <email> (url)"
- */
-declare function parseAuthorString(input: string): AuthorInfo;
-
-export { type AuthorInfo, formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/text/index.js

@@ -1,109 +0,0 @@
-// src/text/bytes.ts
-function formatBytes(bytes, decimals = 2) {
-  if (!+bytes) {
-    return "0 Bytes";
-  }
-  const k = 1e3;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
-}
-
-// src/text/text.ts
-var quoteStyles = {
-  cs: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
-  // Danish, Norwegian - » « › ‹
-  da: { close: "\xAB", closeSingle: "\u203A", open: "\xBB", openSingle: "\u2039" },
-  // German (Germany, Austria) - „ " ‚ '
-  de: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
-  // German (Switzerland) - « » ‹ ›
-  "de-ch": { close: "\xBB", closeSingle: "\u203A", open: "\xAB", openSingle: "\u2039" },
-  // English (US, UK, etc.) - " " ' '
-  en: { close: "\u201D", closeSingle: "\u2019", open: "\u201C", openSingle: "\u2018" },
-  // Spanish, Italian, Portuguese - « » " "
-  es: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
-  fi: { close: "\u201D", closeSingle: "\u2019", open: "\u201D", openSingle: "\u2019" },
-  // French - « » ‹ › (with spaces)
-  fr: { close: " \xBB", closeSingle: " \u203A", open: "\xAB ", openSingle: "\u2039 " },
-  hu: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
-  it: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
-  // Japanese - 「 」 『 』
-  ja: { close: "\u300D", closeSingle: "\u300F", open: "\u300C", openSingle: "\u300E" },
-  // Dutch - ' ' ' '
-  nl: { close: "\u2019", closeSingle: "\u2019", open: "\u2018", openSingle: "\u2018" },
-  no: { close: "\xAB", closeSingle: "\u203A", open: "\xBB", openSingle: "\u2039" },
-  // Polish, Czech, Hungarian - „ " ‚ '
-  pl: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
-  pt: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
-  // Russian - « » ‚ '
-  ru: { close: "\xBB", closeSingle: "\u2019", open: "\xAB", openSingle: "\u201A" },
-  // Swedish, Finnish - " " ' '
-  sv: { close: "\u201D", closeSingle: "\u2019", open: "\u201D", openSingle: "\u2019" },
-  // Chinese - 「 」 『 』
-  zh: { close: "\u300D", closeSingle: "\u300F", open: "\u300C", openSingle: "\u300E" }
-};
-function getQuoteStyle(locale) {
-  const normalized = locale.toLowerCase();
-  const exactMatch = quoteStyles[normalized];
-  if (exactMatch) {
-    return exactMatch;
-  }
-  const baseLanguage = normalized.split("-")[0];
-  if (baseLanguage) {
-    const baseMatch = quoteStyles[baseLanguage];
-    if (baseMatch) {
-      return baseMatch;
-    }
-  }
-  return quoteStyles.en;
-}
-function typographicQuotes(text, locale) {
-  const style = getQuoteStyle(locale);
-  let result = text.replace(/"([^"]*)"/g, `${style.open}$1${style.close}`);
-  result = result.replace(/'([^']*)'/g, `${style.openSingle}$1${style.closeSingle}`);
-  return result;
-}
-function toBoolean(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  return value === "true" || value === "1";
-}
-function replaceShyInString(input) {
-  return input.replace(/&shy;/g, "\xAD");
-}
-function splitIntoSentences(text) {
-  return text.split(/(?<=[.!?])\s+/);
-}
-function splitIntoWords(text) {
-  return text.split(/\s+/);
-}
-function truncateText(text, maxLength, suffix = "...") {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return text.slice(0, maxLength - suffix.length) + suffix;
-}
-var authorRegex = /^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$/;
-function parseAuthorString(input) {
-  const match = input.match(authorRegex);
-  if (match) {
-    const [, name, email, url] = match;
-    const result = {};
-    if (email) {
-      result.email = email;
-    }
-    const trimmedName = name?.trim();
-    if (trimmedName) {
-      result.name = trimmedName;
-    }
-    if (url) {
-      result.url = url;
-    }
-    return result;
-  }
-  return {};
-}
-
-export { formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/time/index.d.ts

@@ -1,48 +0,0 @@
-/** Delays using a promise
- * @param ms Milisecods of delay
- * @return Promise
- */
-declare function delay(ms: number): Promise<unknown>;
-
-declare function measure<Result>(key: string, callback: () => Result | Promise<Result>): Promise<Result>;
-
-declare function timeAgo(input: Date | string): string;
-declare const oneWeekFromNow: () => Date;
-declare const oneDayFromNow: () => Date;
-declare const oneMinuteFromNow: () => Date;
-declare function friendlyDuration(minutes: number | null, locale: string, short?: boolean): {
-    key: string;
-    vars: {
-        hours: string;
-        minutes: string;
-        count?: undefined;
-        value?: undefined;
-    };
-} | {
-    key: string;
-    vars: {
-        hours: string;
-        minutes?: undefined;
-        count?: undefined;
-        value?: undefined;
-    };
-} | {
-    key: string;
-    vars: {
-        minutes: string;
-        hours?: undefined;
-        count?: undefined;
-        value?: undefined;
-    };
-} | {
-    key: string;
-    vars: {
-        count: number;
-        value: string;
-        hours?: undefined;
-        minutes?: undefined;
-    };
-} | null;
-declare const dateTimeInUnix: (date: number) => number;
-
-export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };