@regardio/react 0.4.7 → 0.5.1

package/dist/list/index.d.ts

@@ -0,0 +1,69 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentPropsWithoutRef, ReactNode, ForwardedRef } from 'react';
+
+type ListItemElement = 'li' | 'dd' | 'dt' | 'div' | 'span';
+type ListItemProps<T extends ListItemElement = 'li'> = Omit<ComponentPropsWithoutRef<T>, 'children'> & {
+    /**
+     * The element type to render.
+     * Falls back to the defaultItemElement from ListRoot context, or 'li'.
+     */
+    render?: T;
+    /**
+     * The content of the list item.
+     */
+    children?: ReactNode;
+};
+declare function ListItemImpl<T extends ListItemElement = 'li'>(props: ListItemProps<T>, ref: ForwardedRef<HTMLElement>): react_jsx_runtime.JSX.Element;
+declare const ListItem: <T extends ListItemElement = "li">(props: ListItemProps<T> & {
+    ref?: ForwardedRef<HTMLElement>;
+}) => ReturnType<typeof ListItemImpl>;
+declare namespace ListItem {
+    type Props<T extends ListItemElement = 'li'> = ListItemProps<T>;
+}
+
+interface ListRootContextValue {
+    /**
+     * Default element type for list items.
+     * @default 'li'
+     */
+    defaultItemElement: 'li' | 'dd' | 'dt' | 'div' | 'span';
+    /**
+     * Default className to apply to all list items.
+     */
+    defaultItemClassName?: string;
+}
+
+type ListRootElement = 'ul' | 'ol' | 'dl' | 'div' | 'menu' | 'nav';
+type ListRootProps<T extends ListRootElement = 'ul'> = Omit<ComponentPropsWithoutRef<T>, 'children'> & {
+    /**
+     * The element type to render.
+     * @default 'ul'
+     */
+    render?: T;
+    /**
+     * The content of the list.
+     */
+    children?: ReactNode;
+    /**
+     * Default element type for list items.
+     * When render is 'dl', defaults to 'dd'. Otherwise defaults to 'li'.
+     */
+    defaultItemElement?: ListRootContextValue['defaultItemElement'];
+    /**
+     * Default className to apply to all list items.
+     */
+    defaultItemClassName?: string;
+};
+declare function ListRootImpl<T extends ListRootElement = 'ul'>(props: ListRootProps<T>, ref: ForwardedRef<HTMLElement>): react_jsx_runtime.JSX.Element;
+declare const ListRoot: <T extends ListRootElement = "ul">(props: ListRootProps<T> & {
+    ref?: ForwardedRef<HTMLElement>;
+}) => ReturnType<typeof ListRootImpl>;
+declare namespace ListRoot {
+    type Props<T extends ListRootElement = 'ul'> = ListRootProps<T>;
+}
+
+declare namespace index_parts {
+  export { ListItem as Item, ListRoot as Root };
+}
+
+export { index_parts as List, type ListItemProps, type ListRootContextValue, type ListRootProps };

package/dist/list/index.js

@@ -0,0 +1,65 @@
+import { createContext, forwardRef, useMemo, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/list/index.parts.ts
+var index_parts_exports = {};
+__export(index_parts_exports, {
+  Item: () => ListItem,
+  Root: () => ListRoot
+});
+var ListRootContext = createContext(void 0);
+function useListRootContext() {
+  return useContext(ListRootContext);
+}
+function ListItemImpl(props, ref) {
+  const context = useListRootContext();
+  const { render, children, className, ...elementProps } = props;
+  const resolvedElement = render ?? context?.defaultItemElement ?? "li";
+  const resolvedClassName = context?.defaultItemClassName ? className ? `${context.defaultItemClassName} ${className}` : context.defaultItemClassName : className;
+  const Component = resolvedElement;
+  return /* @__PURE__ */ jsx(
+    Component,
+    {
+      className: resolvedClassName,
+      ref,
+      ...elementProps,
+      children
+    }
+  );
+}
+var ListItem = forwardRef(ListItemImpl);
+function ListRootImpl(props, ref) {
+  const {
+    render = "ul",
+    children,
+    defaultItemElement,
+    defaultItemClassName,
+    ...elementProps
+  } = props;
+  const resolvedDefaultItemElement = defaultItemElement ?? (render === "dl" ? "dd" : "li");
+  const contextValue = useMemo(
+    () => ({
+      defaultItemClassName,
+      defaultItemElement: resolvedDefaultItemElement
+    }),
+    [resolvedDefaultItemElement, defaultItemClassName]
+  );
+  const Component = render;
+  return /* @__PURE__ */ jsx(ListRootContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    Component,
+    {
+      ref,
+      ...elementProps,
+      children
+    }
+  ) });
+}
+var ListRoot = forwardRef(ListRootImpl);
+
+export { index_parts_exports as List };

package/dist/{components/markdown-container.js → markdown-container/index.js}

@@ -1,22 +1,11 @@
 import { MDXProvider } from '@mdx-js/react';
+import { cn } from '@regardio/tailwind/utils';
 import Markdown from 'markdown-to-jsx';
-import { defineConfig, cx } from 'cva';
-import { twMerge } from 'fluid-tailwindcss/tailwind-merge';
+import { typographicQuotes, replaceShyInString } from '@regardio/js/text';
 import React, { isValidElement, cloneElement } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
-// src/components/markdown-container.tsx
-var { cva, compose } = defineConfig({
-  hooks: {
-    onComplete: (className) => {
-      return twMerge(className);
-    }
-  }
-});
-var cn = (...inputs) => twMerge(cx(inputs));
-function replaceShyInString(input) {
-  return input.replace(/­/g, "\xAD");
-}
+// src/markdown-container/markdown-container.tsx
 function replaceShyInReactNode(node) {
   if (typeof node === "string") {
     return node.replace(/\u00AD/g, "");
@@ -43,59 +32,6 @@ function shy(input) {
   }
   return replaceShyInReactNode(input);
 }
-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 replaceSpecialChars(text, locale) {
   return shy(typographicQuotes(text, locale));
 }

package/dist/{components/password-input.js → password-input/index.js}

@@ -1,19 +1,10 @@
 import { Button } from '@base-ui/react/button';
 import { Input } from '@base-ui/react/input';
+import { cn } from '@regardio/tailwind/utils';
 import { useState } from 'react';
-import { defineConfig, cx } from 'cva';
-import { twMerge } from 'fluid-tailwindcss/tailwind-merge';
 import { jsxs, jsx } from 'react/jsx-runtime';
 
-// src/components/password-input.tsx
-var { cva, compose } = defineConfig({
-  hooks: {
-    onComplete: (className) => {
-      return twMerge(className);
-    }
-  }
-});
-var cn = (...inputs) => twMerge(cx(inputs));
+// src/password-input/password-input.tsx
 var PasswordInput = ({ className, ...props }) => {
   const [showPassword, setShowPassword] = useState(false);
   const togglePasswordVisibility = () => {

package/dist/{components/picture.js → picture/index.js}

@@ -1,16 +1,7 @@
-import { defineConfig, cx } from 'cva';
-import { twMerge } from 'fluid-tailwindcss/tailwind-merge';
+import { cn } from '@regardio/tailwind/utils';
 import { jsx, jsxs } from 'react/jsx-runtime';
 
-// src/utils/cn.ts
-var { cva, compose } = defineConfig({
-  hooks: {
-    onComplete: (className) => {
-      return twMerge(className);
-    }
-  }
-});
-var cn = (...inputs) => twMerge(cx(inputs));
+// src/picture/picture.tsx
 var screenSizeVariants = {
   lg: 1280,
   max: 1920,

package/dist/{components/protected-email.d.ts → protected-email/index.d.ts}

@@ -17,4 +17,4 @@ interface ProtectedEmailProps {
  */
 declare function ProtectedEmail({ username, domain, text, className }: ProtectedEmailProps): react_jsx_runtime.JSX.Element;
 
-export { ProtectedEmail };
+export { ProtectedEmail, type ProtectedEmailProps };

package/dist/{components/protected-email.js → protected-email/index.js}

@@ -1,7 +1,7 @@
 import { useState, useEffect } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
-// src/components/protected-email.tsx
+// src/protected-email/protected-email.tsx
 function ProtectedEmail({ username, domain, text, className }) {
   const [mounted, setMounted] = useState(false);
   useEffect(() => {

package/dist/text/index.d.ts

@@ -0,0 +1,20 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentProps } from 'react';
+
+declare const themeColorVariants: {
+    readonly primary: readonly [];
+};
+declare const textVariants: {
+    readonly code: readonly ["font-light", "font-monospace"];
+    readonly primary: readonly [];
+    readonly subtitle: readonly ["text-lg"];
+};
+type TextThemeColor = keyof typeof themeColorVariants;
+type TextVariant = keyof typeof textVariants;
+interface TextProps extends ComponentProps<'p'> {
+    themeColor?: TextThemeColor;
+    variant?: TextVariant;
+}
+declare const Text: ({ children, className, variant, themeColor }: TextProps) => react_jsx_runtime.JSX.Element;
+
+export { Text, type TextProps };

package/dist/text/index.js

@@ -0,0 +1,38 @@
+import { tv } from '@regardio/tailwind/utils';
+import { jsx } from 'react/jsx-runtime';
+
+// src/text/text.tsx
+var themeColorVariants = {
+  primary: []
+};
+var textVariants = {
+  code: ["font-light", "font-monospace"],
+  primary: [],
+  subtitle: ["text-lg"]
+};
+var text = tv({
+  base: ["relative", "block"],
+  defaultVariants: {
+    themeColor: "primary",
+    variant: "primary"
+  },
+  variants: {
+    themeColor: themeColorVariants,
+    variant: textVariants
+  }
+});
+var Text = ({ children, className, variant, themeColor }) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: text({
+        className,
+        themeColor,
+        variant
+      }),
+      children
+    }
+  );
+};
+
+export { Text };

package/dist/utils/author/index.d.ts

@@ -0,0 +1,3 @@
+declare function generateLinkFromAuthorString(input: string): React.ReactNode;
+
+export { generateLinkFromAuthorString };

package/dist/utils/author/index.js

@@ -0,0 +1,33 @@
+import { parseAuthorString } from '@regardio/js/text';
+import { jsx } from 'react/jsx-runtime';
+
+// src/utils/author/author.tsx
+function generateLinkFromAuthorString(input) {
+  const match = parseAuthorString(input);
+  if (match.name) {
+    if (match.email) {
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "u-email p-name",
+          href: `mailto:${match.email}`,
+          children: match.name
+        }
+      );
+    }
+    if (match.url && (match.url.startsWith("/") || match.url.startsWith("http"))) {
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "u-url p-name",
+          href: match.url,
+          children: match.name
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx("span", { className: "p-name", children: match.name });
+  }
+  return;
+}
+
+export { generateLinkFromAuthorString };

package/dist/utils/text/index.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+
+declare const lowerCaseSzett: (text: ReactNode | string, _returnType?: "string") => ReactNode;
+declare function shy(input: string | ReactNode | null): string | ReactNode | null;
+/**
+ * Replace special characters in text: typographic quotes and soft hyphens.
+ * This is a React-aware version that handles ReactNode trees.
+ */
+declare function replaceSpecialChars(text: string, locale: string): string | ReactNode | null;
+/**
+ * Wrap sentences in span elements
+ */
+declare function wrapSentences(text: string): ReactNode;
+
+export { lowerCaseSzett, replaceSpecialChars, shy, wrapSentences };

package/dist/utils/text/index.js

@@ -0,0 +1,73 @@
+import { replaceShyInString, typographicQuotes, splitIntoSentences } from '@regardio/js/text';
+import React, { isValidElement, cloneElement } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/utils/text/text.tsx
+var lowerCaseSzett = (text, _returnType) => {
+  const processString = (str) => {
+    const parts = str.split(/(ß)/g);
+    return parts.map(
+      (part, index) => part === "\xDF" ? /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "lowercase",
+          children: part
+        },
+        index.toString()
+      ) : part
+    );
+  };
+  if (typeof text === "string") {
+    return processString(text);
+  }
+  if (isValidElement(text)) {
+    const element = text;
+    const { children, ...props } = element.props;
+    return cloneElement(element, {
+      ...props,
+      children: lowerCaseSzett(children)
+    });
+  }
+  if (Array.isArray(text)) {
+    return text.map((child, index) => /* @__PURE__ */ jsx(React.Fragment, { children: lowerCaseSzett(child) }, index.toString()));
+  }
+  return text;
+};
+function replaceShyInReactNode(node) {
+  if (typeof node === "string") {
+    return node.replace(/\u00AD/g, "");
+  }
+  if (isValidElement(node)) {
+    const element = node;
+    const { children, ...props } = element.props;
+    return cloneElement(element, {
+      ...props,
+      children: replaceShyInReactNode(children)
+    });
+  }
+  if (Array.isArray(node)) {
+    return node.map((child, index) => /* @__PURE__ */ jsx(React.Fragment, { children: replaceShyInReactNode(child) }, index.toString()));
+  }
+  return node;
+}
+function shy(input) {
+  if (input === null) {
+    return null;
+  }
+  if (typeof input === "string") {
+    return replaceShyInString(input);
+  }
+  return replaceShyInReactNode(input);
+}
+function replaceSpecialChars(text, locale) {
+  return shy(typographicQuotes(text, locale));
+}
+function wrapSentences(text) {
+  const sentences = splitIntoSentences(text);
+  return sentences.map((sentence, index) => /* @__PURE__ */ jsxs("span", { children: [
+    sentence,
+    " "
+  ] }, index.toString()));
+}
+
+export { lowerCaseSzett, replaceSpecialChars, shy, wrapSentences };