@regardio/react 0.3.3 → 0.4.0

package/dist/utils/author.js

@@ -1,37 +1,55 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-const regex = /^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$/;
-export function parseAuthorString(input) {
-    const match = input.match(regex);
-    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;
+import { jsx } from 'react/jsx-runtime';
+
+// src/utils/author.tsx
+var regex = /^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$/;
+function parseAuthorString(input) {
+  const match = input.match(regex);
+  if (match) {
+    const [, name, email, url] = match;
+    const result = {};
+    if (email) {
+      result.email = email;
     }
-    return {};
+    const trimmedName = name?.trim();
+    if (trimmedName) {
+      result.name = trimmedName;
+    }
+    if (url) {
+      result.url = url;
+    }
+    return result;
+  }
+  return {};
 }
-export function generateLinkFromAuthorString(input) {
-    const match = input.match(regex);
-    if (match) {
-        const [, name, email, url] = match.map((part) => {
-            return part?.trim();
-        });
-        if (email) {
-            return (_jsx("a", { className: 'u-email p-name', href: `mailto:${email}`, children: name }));
+function generateLinkFromAuthorString(input) {
+  const match = input.match(regex);
+  if (match) {
+    const [, name, email, url] = match.map((part) => {
+      return part?.trim();
+    });
+    if (email) {
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "u-email p-name",
+          href: `mailto:${email}`,
+          children: name
         }
-        if (url && (url.startsWith('/') || url.startsWith('http'))) {
-            return (_jsx("a", { className: 'u-url p-name', href: url, children: name }));
+      );
+    }
+    if (url && (url.startsWith("/") || url.startsWith("http"))) {
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "u-url p-name",
+          href: url,
+          children: name
         }
-        return _jsx("span", { className: 'p-name', children: name });
+      );
     }
-    return;
+    return /* @__PURE__ */ jsx("span", { className: "p-name", children: name });
+  }
+  return;
 }
+
+export { generateLinkFromAuthorString, parseAuthorString };

package/dist/utils/cn.d.ts

@@ -1,5 +1,9 @@
+import * as cva$1 from 'cva';
 import { cx } from 'cva';
-export type { VariantProps } from 'cva';
-export declare const cva: import("cva").CVA, compose: import("cva").Compose;
-export declare const cn: (...inputs: Parameters<typeof cx>) => string;
-//# sourceMappingURL=cn.d.ts.map
+export { VariantProps } from 'cva';
+
+declare const cva: cva$1.CVA;
+declare const compose: cva$1.Compose;
+declare const cn: (...inputs: Parameters<typeof cx>) => string;
+
+export { cn, compose, cva };

package/dist/utils/cn.js

@@ -1,10 +1,14 @@
-import { cx, defineConfig } from 'cva';
+import { defineConfig, cx } from 'cva';
 import { twMerge } from 'fluid-tailwindcss/tailwind-merge';
-export const { cva, compose } = defineConfig({
-    hooks: {
-        onComplete: (className) => {
-            return twMerge(className);
-        },
-    },
+
+// src/utils/cn.ts
+var { cva, compose } = defineConfig({
+  hooks: {
+    onComplete: (className) => {
+      return twMerge(className);
+    }
+  }
 });
-export const cn = (...inputs) => twMerge(cx(inputs));
+var cn = (...inputs) => twMerge(cx(inputs));
+
+export { cn, compose, cva };

package/dist/utils/is-route-active.d.ts

@@ -1,3 +1,19 @@
-export declare function isRouteActive(path: string, currentPath: string, end?: boolean | ((path: string) => boolean) | undefined): boolean;
-export declare function checkIfRouteIsActive(targetLink: string, currentRoute: string, depth?: number): boolean;
-//# sourceMappingURL=is-route-active.d.ts.map
+/**
+ * @name isRouteActive
+ * @description A function to check if a route is active. This is used to
+ * @param end
+ * @param path
+ * @param currentPath
+ */
+declare function isRouteActive(path: string, currentPath: string, end?: boolean | ((path: string) => boolean) | undefined): boolean;
+/**
+ * @name checkIfRouteIsActive
+ * @description A function to check if a route is active. This is used to
+ * highlight the active link in the navigation.
+ * @param targetLink - The link to check against
+ * @param currentRoute - the current route
+ * @param depth - how far down should segments be matched?
+ */
+declare function checkIfRouteIsActive(targetLink: string, currentRoute: string, depth?: number): boolean;
+
+export { checkIfRouteIsActive, isRouteActive };

package/dist/utils/is-route-active.js

@@ -1,54 +1,56 @@
-const ROOT_PATH = '/';
-export 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);
+// src/utils/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);
 }
-export 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 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);
+  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);
+  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;
-        }
+  let count = 0;
+  for (const segment of splitIntoSegments(href)) {
+    if (segments.includes(segment)) {
+      count += 1;
+    } else {
+      return count;
     }
-    return count;
+  }
+  return count;
 }
 function isRoot(path) {
-    return path === ROOT_PATH;
+  return path === ROOT_PATH;
 }
+
+export { checkIfRouteIsActive, isRouteActive };

package/dist/utils/locale.d.ts

@@ -1,22 +1,84 @@
 import { LanguageDetectorLingui } from '@regardio/js/intl/language-detector';
 import { createCookie } from 'react-router';
-export interface LocaleConfigOptions {
+
+/**
+ * Configuration options for creating locale utilities
+ */
+interface LocaleConfigOptions {
+    /**
+     * Default locale to use as fallback
+     */
     defaultLocale: string;
+    /**
+     * List of supported locales
+     */
     supportedLocales: readonly string[];
+    /**
+     * Cookie options for storing locale preference
+     */
     cookieOptions?: {
+        /**
+         * Name of the cookie (default: 'locale')
+         */
         name?: string;
+        /**
+         * Max age of the cookie in seconds (default: 1 year)
+         */
         maxAge?: number;
+        /**
+         * Whether the cookie should be HTTP only (default: false)
+         */
         httpOnly?: boolean;
+        /**
+         * Whether the cookie should be secure (default: true in production)
+         */
         secure?: boolean;
+        /**
+         * SameSite attribute for the cookie (default: 'lax')
+         */
         sameSite?: 'strict' | 'lax' | 'none';
     };
+    /**
+     * Detection options for the language detector
+     */
     detectionOptions?: {
+        /**
+         * Order of detection methods (default: ['urlPath', 'cookie', 'header'])
+         */
         order?: Array<'urlPath' | 'cookie' | 'header'>;
     };
 }
-export interface LocaleConfig {
+/**
+ * Result of createLocaleConfig
+ */
+interface LocaleConfig {
+    /**
+     * Cookie for storing locale preference
+     */
     localeCookie: ReturnType<typeof createCookie>;
+    /**
+     * Language detector instance
+     */
     languageDetector: LanguageDetectorLingui;
 }
-export declare function createLocaleConfig(options: LocaleConfigOptions): LocaleConfig;
-//# sourceMappingURL=locale.d.ts.map
+/**
+ * Create locale configuration utilities
+ *
+ * This function creates a unified locale cookie and language detector
+ * based on the provided configuration options.
+ *
+ * @param options Configuration options
+ * @returns Locale configuration utilities
+ *
+ * @example
+ * ```ts
+ * // In your app's configuration file
+ * const { localeCookie, languageDetector } = createLocaleConfig({
+ *   defaultLocale: 'en',
+ *   supportedLocales: ['en', 'de', 'fr'],
+ * });
+ * ```
+ */
+declare function createLocaleConfig(options: LocaleConfigOptions): LocaleConfig;
+
+export { type LocaleConfig, type LocaleConfigOptions, createLocaleConfig };

package/dist/utils/locale.js

@@ -1,25 +1,36 @@
 import { LanguageDetectorLingui } from '@regardio/js/intl/language-detector';
 import { createCookie } from 'react-router';
-export function createLocaleConfig(options) {
-    const { defaultLocale, supportedLocales, cookieOptions = {}, detectionOptions = {} } = options;
-    const { name = 'locale', maxAge = 60 * 60 * 24 * 365, httpOnly = false, secure = import.meta.env.MODE !== 'development', sameSite = 'lax', } = cookieOptions;
-    const { order = ['urlPath', 'cookie', 'header'] } = detectionOptions;
-    const localeCookie = createCookie(name, {
-        httpOnly,
-        maxAge,
-        sameSite,
-        secure,
-    });
-    const languageDetector = new LanguageDetectorLingui({
-        detection: {
-            cookie: localeCookie,
-            fallbackLanguage: defaultLocale,
-            order,
-            supportedLanguages: [...supportedLocales],
-        },
-    });
-    return {
-        languageDetector,
-        localeCookie,
-    };
+
+// src/utils/locale.ts
+function createLocaleConfig(options) {
+  const { defaultLocale, supportedLocales, cookieOptions = {}, detectionOptions = {} } = options;
+  const {
+    name = "locale",
+    maxAge = 60 * 60 * 24 * 365,
+    // 1 year
+    httpOnly = false,
+    secure = import.meta.env.MODE !== "development",
+    sameSite = "lax"
+  } = cookieOptions;
+  const { order = ["urlPath", "cookie", "header"] } = detectionOptions;
+  const localeCookie = createCookie(name, {
+    httpOnly,
+    maxAge,
+    sameSite,
+    secure
+  });
+  const languageDetector = new LanguageDetectorLingui({
+    detection: {
+      cookie: localeCookie,
+      fallbackLanguage: defaultLocale,
+      order,
+      supportedLanguages: [...supportedLocales]
+    }
+  });
+  return {
+    languageDetector,
+    localeCookie
+  };
 }
+
+export { createLocaleConfig };

package/dist/utils/text.d.ts

@@ -1,7 +1,24 @@
-import React, { type ReactNode } from 'react';
-export declare const lowerCaseSzett: (text: ReactNode | string, _returnType?: "string") => ReactNode;
-export declare function toBoolean(value: string | boolean | null | undefined): boolean;
-export declare function shy(input: string | ReactNode | null): string | ReactNode | null;
-export declare function typographicQuotes(text: string, locale: string): string;
-export declare function replaceSpecialChars(text: string, locale: string): React.ReactNode;
-//# sourceMappingURL=text.d.ts.map
+import react__default, { ReactNode } from 'react';
+
+declare const lowerCaseSzett: (text: ReactNode | string, _returnType?: "string") => ReactNode;
+declare function toBoolean(value: string | boolean | null | undefined): boolean;
+declare function shy(input: string | ReactNode | null): string | ReactNode | null;
+/**
+ * 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;
+/**
+ * @deprecated Use `typographicQuotes` for quote replacement and `shy` separately
+ */
+declare function replaceSpecialChars(text: string, locale: string): react__default.ReactNode;
+
+export { lowerCaseSzett, replaceSpecialChars, shy, toBoolean, typographicQuotes };