aidos-ui 4.0.4 → 4.0.5

package/src/useCookie.tsx

@@ -1,95 +0,0 @@
-import { useState, useCallback, useEffect, useRef } from "react";
-import { isServer } from "./isServer";
-
-export function hasCookie(key: string): boolean {
-  return (
-    document.cookie
-      .split(";")
-      .map((c) => c.trim())
-      .filter((c) => c.startsWith(`${key}=`)).length > 0
-  );
-}
-
-export function getCookie<T>(
-  key: string,
-  deserialize: (s: string) => T = JSON.parse
-): T {
-  return document.cookie
-    .split(";")
-    .map((c) => c.trim())
-    .filter((c) => c.startsWith(`${key}=`))
-    .map((s) => s.split("=")[1])
-    .map((s) => deserialize(s))
-    .reverse()
-    .pop();
-}
-
-export function useCookie<T, L>(
-  key: string,
-  {
-    initialValue = null,
-    loadingValue,
-    serialize = JSON.stringify,
-    deserialize = JSON.parse,
-    maxAge = 60 * 60 * 24 * 365,
-  }: {
-    initialValue: T;
-    loadingValue: L;
-    serialize?: (t: T) => string;
-    deserialize?: (s: string) => T;
-    maxAge?: number;
-  }
-): [T | L, (t: T | ((prevValue: T | L) => T)) => void] {
-  const initializationRef = useRef(false);
-  const [cookie, setCookie] = useState<T | L>(() => {
-    if (!isServer()) {
-      const hasPersistedCookie = hasCookie(key);
-      if (hasPersistedCookie) {
-        return getCookie(key, deserialize);
-      } else {
-        return loadingValue;
-      }
-    }
-
-    return loadingValue;
-  });
-
-  useEffect(() => {
-    if (initializationRef.current === true) {
-      return;
-    }
-
-    const hasPersistedCookie = hasCookie(key);
-
-    if (hasPersistedCookie) {
-      const persistedCookie = getCookie(key, deserialize);
-      setCookie(persistedCookie);
-    } else {
-      document.cookie = `${key}=${serialize(
-        initialValue
-      )}; max-age=${maxAge};path=/;`;
-      setCookie(initialValue);
-    }
-    initializationRef.current = true;
-  }, []);
-
-  return [
-    cookie,
-    useCallback((t: T | ((prevValue: T | L) => T)) => {
-      if (typeof t === "function") {
-        // @ts-ignore
-        const callback: (prevValue: T | L) => T = t;
-        setCookie((oldCookie) => {
-          const newValue = callback(oldCookie);
-          document.cookie = `${key}=${serialize(
-            newValue
-          )}; max-age=${maxAge};path=/;`;
-          return newValue;
-        });
-      } else {
-        setCookie(t);
-        document.cookie = `${key}=${serialize(t)}; max-age=${maxAge};path=/;`;
-      }
-    }, []),
-  ];
-}

package/src/useKeyboard.tsx

@@ -1,43 +0,0 @@
-import { useRefEffect } from "./useRefEffect";
-
-export type KeyboardShortcut<T> = {
-  key: string;
-  metaKey?: boolean;
-  ctrlKey?: boolean;
-  action: (root: T) => void;
-  onlyWhenFocused?: boolean;
-};
-
-export function useKeyboard<T extends HTMLElement>(
-  shortcuts: Array<KeyboardShortcut<T>>
-) {
-  return useRefEffect<T>((root: T) => {
-    const onKeyDown = (e: KeyboardEvent) => {
-      for (const {
-        metaKey,
-        key,
-        action,
-        ctrlKey,
-        onlyWhenFocused,
-      } of shortcuts) {
-        if (metaKey && e.metaKey !== true) {
-          continue;
-        } else if (ctrlKey && e.ctrlKey !== true) {
-          continue;
-        } else if (onlyWhenFocused && document.activeElement !== root) {
-          continue;
-        }
-
-        if (e.key.toLowerCase() === key.toLowerCase()) {
-          action(root);
-        }
-      }
-    };
-
-    window.addEventListener("keydown", onKeyDown);
-
-    return () => {
-      window.removeEventListener("keydown", onKeyDown);
-    };
-  });
-}

package/src/useNavigation.tsx

@@ -1,89 +0,0 @@
-import { useRef, useCallback, useEffect } from "react";
-
-import { queryFocusables, focusElement, normalizeElements } from "./aria";
-import { useRefEffect } from "./useRefEffect";
-
-export function useNavigation({
-  autofocus = false,
-  rowLength = 1,
-  enabled = true,
-} = {}) {
-  return useRefEffect((root: HTMLElement) => {
-    if (!enabled) {
-      return;
-    }
-
-    let index = 0;
-
-    const elements = queryFocusables(root);
-
-    if (elements.length === 0) {
-      return;
-    }
-
-    if (elements.length !== 0 && autofocus) {
-      focusElement(elements, index);
-    } else {
-      normalizeElements(elements, index);
-    }
-
-    const onKeyDown = (e: KeyboardEvent) => {
-      const elements = queryFocusables(root);
-
-      if (elements.length === 0) {
-        return;
-      }
-
-      let newIndex: number = -1;
-
-      if (e.code === "ArrowUp") {
-        if (index - rowLength < 0) {
-          newIndex = elements.length - (elements.length % rowLength) + index;
-        } else {
-          newIndex = index - rowLength;
-        }
-      } else if (e.code === "ArrowLeft") {
-        if (index <= 0) {
-          newIndex = elements.length - 1;
-        } else {
-          newIndex = index - 1;
-        }
-      } else if (e.code === "ArrowRight") {
-        if (index >= elements.length - 1) {
-          newIndex = 0;
-        } else {
-          newIndex = index + 1;
-        }
-      } else if (e.code === "ArrowDown") {
-        if (index + rowLength > elements.length - 1) {
-          newIndex = (index + rowLength) % rowLength;
-        } else {
-          newIndex = index + rowLength;
-        }
-      }
-
-      if (newIndex !== -1 && index !== newIndex) {
-        index = newIndex;
-        focusElement(elements, index);
-        e.preventDefault();
-        e.stopPropagation();
-      }
-    };
-
-    root.addEventListener("keydown", onKeyDown);
-
-    const observer = new MutationObserver((mutationList) => {
-      if (mutationList.filter((m) => m.type === "childList").length > 0) {
-        const elements = queryFocusables(root);
-        if (elements.length > 0) {
-          normalizeElements(elements, index);
-        }
-      }
-    });
-    observer.observe(root, { childList: true });
-
-    return () => {
-      root.removeEventListener("keydown", onKeyDown);
-    };
-  });
-}

package/src/usePromise.tsx

@@ -1,18 +0,0 @@
-import { useState, useEffect } from "react";
-
-export function usePromise<T>(
-  promiseFactory: () => Promise<T>,
-  inputs: Array<any>,
-  initialValue: T
-): [T | null, any] {
-  const [value, setValue] = useState(initialValue);
-  const [error, setError] = useState(null);
-
-  useEffect(() => {
-    promiseFactory()
-      .then((value) => setValue(value))
-      .catch((error) => setError(error));
-  }, inputs);
-
-  return [value, error];
-}

package/src/useRefEffect.tsx

@@ -1,18 +0,0 @@
-import { useRef, useCallback } from "react";
-
-export function useRefEffect<T>(
-  callback: (root: T) => (() => void) | void
-): (root: T) => void {
-  const unsubscribeRef = useRef<(() => void) | void>(null);
-
-  const refCallback = useCallback((root: T | null) => {
-    if (root === null) {
-      unsubscribeRef.current && unsubscribeRef.current();
-    } else {
-      const unsubscribe = callback(root);
-      unsubscribeRef.current = unsubscribe;
-    }
-  }, []);
-
-  return refCallback;
-}

package/src/vite-plugin-jss-debug.ts

@@ -1,77 +0,0 @@
-import path from "path";
-
-/**
- * Vite plugin that enables JSS debug tooling:
- *
- * 1. Injects component names into toClassnames() calls so they appear as CSS classes.
- *    toClassnames(jss) → toClassnames(jss, "Card")
- *
- * 2. Configures the custom JSX dev runtime that injects <!-- ComponentName -->
- *    HTML comments at component boundaries (same approach as the Next.js setup).
- *
- * Usage in vite.config.ts:
- *   import jssDebug from "aidos-ui/vite-plugin-jss-debug";
- *   export default defineConfig({ plugins: [jssDebug()] });
- */
-export default function jssDebug() {
-  return [
-    {
-      name: "jss-debug-jsx",
-      config(_config: unknown, { command }: { command: string }) {
-        return {
-          oxc: {
-            jsx: {
-              runtime: "automatic",
-              development: command === "serve",
-              importSource: "aidos-ui",
-            },
-          },
-        };
-      },
-    },
-    {
-      name: "jss-debug-classnames",
-      enforce: "pre" as const,
-
-      transform(code: string, id: string) {
-        if (id.includes("node_modules")) return;
-        if (!id.match(/\.[jt]sx?$/)) return;
-        if (!code.includes("toClassnames(")) return;
-
-        const filename = path.basename(id, path.extname(id));
-        const name = JSON.stringify(filename);
-        const needle = "toClassnames(";
-        let result = "";
-        let i = 0;
-
-        while (i < code.length) {
-          const idx = code.indexOf(needle, i);
-          if (idx === -1) {
-            result += code.slice(i);
-            break;
-          }
-
-          // Copy everything up to and including "toClassnames("
-          result += code.slice(i, idx + needle.length);
-          i = idx + needle.length;
-
-          // Track parens to find the matching closing )
-          let depth = 1;
-          let j = i;
-          while (j < code.length && depth > 0) {
-            const ch = code[j];
-            if (ch === "(") depth++;
-            else if (ch === ")") depth--;
-            if (depth > 0) j++;
-          }
-
-          // Copy the original arguments, then inject the component name
-          result += code.slice(i, j) + ", " + name;
-          i = j;
-        }
-
-        return { code: result, map: null };
-      },
-    },
-  ];
-}

package/tsconfig.build.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["dom", "dom.iterable", "es2020", "es2020.string"],
-    "target": "ES2020",
-    "module": "esnext",
-    "sourceMap": true,
-    "outDir": "dist/",
-    "jsx": "react-jsx",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "declaration": true,
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": false,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": false,
-    "incremental": false,
-    "resolveJsonModule": true,
-    "isolatedModules": true
-  },
-  "include": ["src/*"],
-  "exclude": ["node_modules"]
-}

package/tsconfig.json

@@ -1,38 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "es2020",
-      "es2020.string"
-    ],
-    "target": "ES2020",
-    "module": "esnext",
-    "sourceMap": true,
-    "outDir": "dist/",
-    "jsx": "react-jsx",
-    "jsxImportSource": "aidos-ui-jsx",
-    "baseUrl": ".",
-    "paths": {
-      "aidos-ui-jsx/jsx-dev-runtime": ["./src/jsx-dev-runtime"],
-      "aidos-ui-jsx/jsx-runtime": ["./src/jsx-runtime"]
-    },
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "declaration": true,
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": false,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": false,
-    "incremental": false,
-    "resolveJsonModule": true,
-    "isolatedModules": true
-  },
-  "include": [
-    "src/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}