nexus-shared 1.1.20 → 2.0.0

package/dist/Services/BrowserApi.js

@@ -0,0 +1,111 @@
+"use client";
+import { messageBox } from "../Components/Layouts/MessageBox.js";
+import { toast } from "../Components/Layouts/Toaster.js";
+import { apiCallContext, createApiClient } from "../Helpers/ApiClient.js";
+import { unwrapApiResult } from "../Helpers/ApiResponses.js";
+import { getApiModules } from "../Helpers/ApiModules.js";
+import { isApiEndpoint, joinUrl } from "../Helpers/ApiRoutes.js";
+import { planApiToast, planLoadingToast } from "../Helpers/ApiToasts.js";
+import { buildMessage } from "../Helpers/MessageBuilder.js";
+let settings = {};
+/**
+ * Sets up `api` for the app. Call it once in a client module that the root layout loads; later calls change only the
+ * settings they name. Nothing is needed when the proxy is at `/api/app` and the defaults suit.
+ */
+export function configureApi(config) {
+    settings = { ...settings, ...config };
+}
+/** Nexus error code for an expired token. */
+const TOKEN_EXPIRED = 2003;
+const TOAST_DURATION = 5000;
+function showToast(plan, id) {
+    // `icon`, `duration`, and `closable` are set, so a loading toast turned into this one loses its spinner and timer.
+    toast(plan.title, { id, tone: plan.tone, message: plan.message, icon: undefined, duration: TOAST_DURATION, closable: true });
+}
+const config = {
+    resolveUrl: (endpoint, path) => joinUrl(getApiModules().browserUrl(endpoint.module), path),
+    headers: call => settings.headers?.(call),
+    token: call => settings.token?.(call),
+    get timeout() {
+        return settings.timeout;
+    },
+    get credentials() {
+        return settings.credentials;
+    },
+    dedupe: true,
+    onStart(call) {
+        const loading = planLoadingToast(call.context, call.options.toast);
+        const loadingId = loading ? toast.loading(loading) : undefined;
+        return result => {
+            if (result.status === 401 || result.errorCode === TOKEN_EXPIRED)
+                settings.onSignedOut?.(result);
+            settings.onResult?.(result, call);
+            const plan = planApiToast(result, call.method, call.context, call.options.toast, settings.toast);
+            if (!plan) {
+                if (loadingId)
+                    toast.dismiss(loadingId);
+                return;
+            }
+            // The same failure twice (two lists on a page loading the same URL) shows one toast, not two.
+            showToast(plan, loadingId ?? (plan.tone === "danger" && call.url ? `nx-api:${call.method}:${call.url}` : undefined));
+        };
+    },
+};
+const client = createApiClient(config);
+/** Actions that lose something, asked about in red. */
+const DESTRUCTIVE = new Set(["delete", "trash", "reject", "cancel"]);
+/**
+ * Asks first, then sends. The question comes from the message builder ("Delete Room 204?", "This cannot be undone.",
+ * a Delete button, in red for actions that lose something). Resolves with the answer, or `null` when the user said no.
+ */
+async function confirmThenSend(target, { question, ...options } = {}) {
+    const { context } = apiCallContext(target, options);
+    const yes = await messageBox.confirm({
+        title: buildMessage("confirm", context),
+        message: buildMessage("confirmDetail", context) || undefined,
+        tone: typeof context.action === "string" && DESTRUCTIVE.has(context.action) ? "danger" : "question",
+        confirmLabel: buildMessage("label", context),
+        ...question,
+    });
+    return yes ? client.send(target, options) : null;
+}
+/**
+ * Calls APIs from the browser, with toasts.
+ *
+ * @example
+ * const ROOMS = MODULES.controller(NexusModule.Reservation, "Room", "room");   // MODULES: the app's defineApiModules(…)
+ *
+ * const rooms = await api.get<Room[]>(ROOMS.listing);                  // error toast if it fails
+ * if (rooms.ok) setRows(rooms.result);
+ *
+ * await api.put(ROOMS.update, values, { subject: `Room ${values.number}` });   // "Room 204 saved." or why not
+ * await api.delete(ROOMS.delete, { params: { id }, toast: { loading: true } });
+ * await api.confirm(ROOMS.delete, { params: { id }, subject: "Room 204" });   // "Delete Room 204?" first; null if not
+ * await api.post("/api/demo-rooms", values, { toast: false });        // a URL, no toasts
+ */
+export const api = Object.assign(client, { confirm: confirmThenSend });
+/**
+ * A dropdown's `loadOptions` for an API that sends pages (`{ results, totalCount, filterCount }`) or a whole list.
+ * Failures show in the dropdown, with Retry, not as a toast.
+ *
+ * @example
+ * <Dropdown name="roomId" label="Room" valueKey="id" labelKey="number" loadOptions={apiOptionsLoader(ROOMS.pagination)} />
+ */
+export function apiOptionsLoader(target, { toItem, request, call } = {}) {
+    const method = call?.method ?? (isApiEndpoint(target) ? target.method : "GET");
+    return async (page) => {
+        const sent = request ? request(page) : { searchKeyword: page.search || undefined, skipCount: page.skip, maxCount: page.pageSize };
+        const answer = unwrapApiResult(await api.send(target, {
+            ...call,
+            method,
+            ...(method === "GET" ? { query: { ...call?.query, ...sent } } : { body: sent }),
+            signal: page.signal,
+            toast: false,
+        }));
+        const rows = Array.isArray(answer) ? answer : (answer?.results ?? []);
+        const items = toItem ? rows.map(toItem) : rows;
+        if (Array.isArray(answer))
+            return { items, hasMore: false, total: items.length };
+        return { items, total: answer?.filterCount, hasMore: page.skip + rows.length < (answer?.filterCount ?? 0) };
+    };
+}

package/dist/Services/ServerApi.d.ts

@@ -0,0 +1,49 @@
+import { type ApiCall } from "../Helpers/ApiClient.ts";
+import type { ApiModuleValue, ApiResult } from "../Interfaces/ApiInterfaces.ts";
+/** Options of a server call, on top of every call's options. */
+export interface ServerApiOptions {
+    /** Keeps the answer in the Next.js data cache for this many seconds; `false` until a tag is revalidated. Default: not cached. */
+    revalidate?: number | false;
+    /** Cache tags, to refresh the answer with `revalidateTag`. Alone, they keep the answer until then. */
+    tags?: string[];
+    /** The bearer token for this call. Default: the `token` of `configureServerApi`; `null` sends none. */
+    token?: string | null;
+}
+/** How server calls behave. Where they go (each module's root) is the app's `ApiModules`. */
+export interface ServerApiConfig {
+    /** The app's own address, for relative roots and URLs such as `/api/…`. Default: `URL_CURRENT` from the environment. */
+    origin?: string | (() => string | undefined | Promise<string | undefined>);
+    /** The user's token for every call, such as from the session cookie. */
+    token?: () => string | null | undefined | Promise<string | null | undefined>;
+    /** Headers on every call, such as the tenant or branch. */
+    headers?: (call: ApiCall<ServerApiOptions>) => Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
+    /** Milliseconds to wait for an answer. Default 60,000. */
+    timeout?: number;
+    /** After every answer. Default: logs network failures, timeouts, and 5xx answers with `console.error`. */
+    onResult?: (result: ApiResult, call: ApiCall<ServerApiOptions>) => void;
+}
+/**
+ * Sets up `serverApi` and the proxy. Call it in a server module that the calls import; later calls change only the
+ * settings they name. Nothing is needed when the modules' roots are absolute and calls need no token.
+ *
+ * @example
+ * configureServerApi({ token: async () => (await cookies()).get("access_token")?.value });
+ */
+export declare function configureServerApi(config: ServerApiConfig): void;
+/**
+ * A module's absolute root URL on the server, from the app's `ApiModules`. Throws "The Reservation API address is not
+ * set (API_RESERVATION)." when it is missing. `origin` resolves a relative root, such as the proxy's request origin.
+ */
+export declare function serverModuleRoot(module: ApiModuleValue, origin?: string): Promise<string>;
+/**
+ * Calls APIs from the server. Import it from `nexus-shared/server`.
+ *
+ * @example
+ * // A server component
+ * const rooms = await serverApi.get<Room[]>(ROOMS.listing, { revalidate: 60, tags: ["rooms"] });
+ * if (!rooms.ok) return <p>{rooms.message}</p>;
+ *
+ * // Or let the error boundary show it
+ * const room = unwrapApiResult(await serverApi.get<Room>(ROOMS.details, { params: { id } }));
+ */
+export declare const serverApi: import("../Shared.Index.ts").ApiClient<ServerApiOptions>;

package/dist/Services/ServerApi.js

@@ -0,0 +1,75 @@
+import { createApiClient } from "../Helpers/ApiClient.js";
+import { describeEndpoint, getApiModules, readEnvironment } from "../Helpers/ApiModules.js";
+import { joinUrl } from "../Helpers/ApiRoutes.js";
+let settings = {};
+/**
+ * Sets up `serverApi` and the proxy. Call it in a server module that the calls import; later calls change only the
+ * settings they name. Nothing is needed when the modules' roots are absolute and calls need no token.
+ *
+ * @example
+ * configureServerApi({ token: async () => (await cookies()).get("access_token")?.value });
+ */
+export function configureServerApi(config) {
+    settings = { ...settings, ...config };
+}
+async function appOrigin() {
+    const value = typeof settings.origin === "function" ? await settings.origin() : settings.origin;
+    return value || readEnvironment("URL_CURRENT");
+}
+async function absolute(url, fallbackOrigin) {
+    if (/^https?:\/\//i.test(url))
+        return url;
+    const origin = fallbackOrigin ?? (await appOrigin());
+    if (!origin)
+        throw new Error(`"${url}" is relative, and the app's address is not set (URL_CURRENT).`);
+    return new URL(url.startsWith("/") ? url : `/${url}`, origin).toString();
+}
+/**
+ * A module's absolute root URL on the server, from the app's `ApiModules`. Throws "The Reservation API address is not
+ * set (API_RESERVATION)." when it is missing. `origin` resolves a relative root, such as the proxy's request origin.
+ */
+export async function serverModuleRoot(module, origin) {
+    return absolute(await getApiModules().serverUrl(module), origin);
+}
+/** Where a call went, for logs: the module and path, never the query (it may hold what a user searched for). */
+function describeCall(call) {
+    const where = call.url ? call.url.split("?")[0] : call.endpoint ? describeEndpoint(call.endpoint) : String(call.target);
+    return `${call.method} ${where}`;
+}
+function logFailure(result, call) {
+    if (result.ok || result.aborted)
+        return;
+    const status = result.status;
+    if (result.network || result.timeout || status === undefined || status >= 500)
+        console.error(`[serverApi] ${describeCall(call)}: ${status ?? ""} ${result.message ?? ""}`.replace(/\s+/g, " ").trim());
+}
+/**
+ * Calls APIs from the server. Import it from `nexus-shared/server`.
+ *
+ * @example
+ * // A server component
+ * const rooms = await serverApi.get<Room[]>(ROOMS.listing, { revalidate: 60, tags: ["rooms"] });
+ * if (!rooms.ok) return <p>{rooms.message}</p>;
+ *
+ * // Or let the error boundary show it
+ * const room = unwrapApiResult(await serverApi.get<Room>(ROOMS.details, { params: { id } }));
+ */
+export const serverApi = createApiClient({
+    resolveUrl: async (endpoint, path) => joinUrl(await serverModuleRoot(endpoint.module), path),
+    resolveTarget: url => absolute(url),
+    headers: call => settings.headers?.(call),
+    token: call => (call.options.token !== undefined ? call.options.token : settings.token?.()),
+    get timeout() {
+        return settings.timeout;
+    },
+    prepare(init, call) {
+        const { revalidate, tags } = call.options;
+        // Next.js reads `next` and `cache` on a server fetch; `no-store` with `revalidate` would cancel both.
+        if (revalidate !== undefined)
+            return { ...init, next: { revalidate, ...(tags && { tags }) } };
+        if (tags)
+            return { ...init, cache: "force-cache", next: { tags } };
+        return { ...init, cache: "no-store" };
+    },
+    onResult: (result, call) => (settings.onResult ?? logFailure)(result, call),
+});

package/dist/Services/ThemeService.d.ts

@@ -0,0 +1,17 @@
+import { type ThemeMode } from "../Interfaces/ThemeInterfaces.ts";
+export interface ThemeState {
+    /** The active theme id. */
+    theme: string;
+    /** The chosen mode, which may be `system`. */
+    mode: ThemeMode;
+    /** The mode actually shown. */
+    resolvedMode: "light" | "dark";
+    setTheme: (theme: string) => void;
+    setMode: (mode: ThemeMode) => void;
+}
+/** Switches the theme on this page and saves it for the next visit. */
+export declare function setTheme(theme: string): void;
+/** Switches light, dark, or system on this page and saves it for the next visit. */
+export declare function setThemeMode(mode: ThemeMode): void;
+/** The current theme and mode, and functions to change them. */
+export declare function useTheme(): ThemeState;

package/dist/Services/ThemeService.js

@@ -0,0 +1,83 @@
+"use client";
+import { useSyncExternalStore } from "react";
+import { THEME_ID_PATTERN } from "../Helpers/ThemeHelpers.js";
+import { DEFAULT_THEME, THEME_ATTRIBUTE, THEME_MODE_ATTRIBUTE, THEME_MODE_STORAGE_KEY, THEME_STORAGE_KEY, } from "../Interfaces/ThemeInterfaces.js";
+const DARK_QUERY = "(prefers-color-scheme: dark)";
+// Before hydration there is no document; the real values follow right after.
+const SERVER_SNAPSHOT = `${DEFAULT_THEME} system light`;
+// Colors switch at once, instead of every button and border running its own transition.
+function withoutTransitions(change) {
+    const style = document.createElement("style");
+    style.textContent = "*,*::before,*::after{transition:none!important}";
+    document.head.appendChild(style);
+    change();
+    void window.getComputedStyle(document.body).color;
+    window.setTimeout(() => style.remove(), 1);
+}
+function save(key, value) {
+    try {
+        localStorage.setItem(key, value);
+    }
+    catch {
+        // Storage blocked (private mode, for example): the choice lasts until the page reloads.
+    }
+}
+function applyTheme(theme) {
+    withoutTransitions(() => document.documentElement.setAttribute(THEME_ATTRIBUTE, theme));
+}
+function applyMode(mode) {
+    const root = document.documentElement;
+    withoutTransitions(() => (mode === "system" ? root.removeAttribute(THEME_MODE_ATTRIBUTE) : root.setAttribute(THEME_MODE_ATTRIBUTE, mode)));
+}
+/** Switches the theme on this page and saves it for the next visit. */
+export function setTheme(theme) {
+    if (!THEME_ID_PATTERN.test(theme))
+        return;
+    applyTheme(theme);
+    save(THEME_STORAGE_KEY, theme);
+}
+/** Switches light, dark, or system on this page and saves it for the next visit. */
+export function setThemeMode(mode) {
+    applyMode(mode);
+    save(THEME_MODE_STORAGE_KEY, mode);
+}
+function readSnapshot() {
+    const root = document.documentElement;
+    const theme = root.getAttribute(THEME_ATTRIBUTE) || DEFAULT_THEME;
+    const attribute = root.getAttribute(THEME_MODE_ATTRIBUTE);
+    const mode = attribute === "light" || attribute === "dark" ? attribute : "system";
+    const resolved = mode === "system" ? (window.matchMedia(DARK_QUERY).matches ? "dark" : "light") : mode;
+    return `${theme} ${mode} ${resolved}`;
+}
+// The attributes on <html> are the source of truth, so every picker on the page stays in step,
+// including changes made by the system setting or in another tab.
+function subscribe(onChange) {
+    const observer = new MutationObserver(onChange);
+    observer.observe(document.documentElement, { attributes: true, attributeFilter: [THEME_ATTRIBUTE, THEME_MODE_ATTRIBUTE] });
+    const media = window.matchMedia(DARK_QUERY);
+    media.addEventListener("change", onChange);
+    const onStorage = (event) => {
+        if (event.key === THEME_STORAGE_KEY && event.newValue && THEME_ID_PATTERN.test(event.newValue))
+            applyTheme(event.newValue);
+        if (event.key === THEME_MODE_STORAGE_KEY && (event.newValue === "light" || event.newValue === "dark" || event.newValue === "system")) {
+            applyMode(event.newValue);
+        }
+    };
+    window.addEventListener("storage", onStorage);
+    return () => {
+        observer.disconnect();
+        media.removeEventListener("change", onChange);
+        window.removeEventListener("storage", onStorage);
+    };
+}
+/** The current theme and mode, and functions to change them. */
+export function useTheme() {
+    const [theme, mode, resolvedMode] = useSyncExternalStore(subscribe, readSnapshot, () => SERVER_SNAPSHOT).split(" ");
+    return {
+        theme: theme ?? DEFAULT_THEME,
+        mode: (mode ?? "system"),
+        resolvedMode: resolvedMode === "dark" ? "dark" : "light",
+        setTheme,
+        setMode: setThemeMode,
+    };
+}

package/dist/Shared.Index.d.ts

@@ -0,0 +1,43 @@
+export * from "./Components/Documents/Button.tsx";
+export * from "./Components/Inputs/Field.tsx";
+export * from "./Components/Layouts/ThemeScript.tsx";
+export * from "./Components/Viewers/MarkdownView.tsx";
+export * from "./Components/Viewers/RichTextView.tsx";
+export * from "./Helpers/ApiClient.ts";
+export * from "./Helpers/ApiFormHelpers.ts";
+export * from "./Helpers/ApiModules.ts";
+export * from "./Helpers/ApiResponses.ts";
+export * from "./Helpers/ApiRoutes.ts";
+export * from "./Helpers/ApiToasts.ts";
+export * from "./Helpers/ClassHelpers.ts";
+export * from "./Helpers/CrudBackend.ts";
+export * from "./Helpers/CrudHelpers.ts";
+export * from "./Helpers/DateHelpers.ts";
+export * from "./Helpers/DateTimeHelpers.ts";
+export * from "./Helpers/DropdownHelpers.ts";
+export * from "./Helpers/FormDrafts.ts";
+export * from "./Helpers/FormStore.ts";
+export * from "./Helpers/InputParamsHelpers.ts";
+export * from "./Helpers/MarkdownEditing.ts";
+export * from "./Helpers/MarkdownHelpers.ts";
+export * from "./Helpers/MessageBuilder.ts";
+export * from "./Helpers/NepaliCalendar.ts";
+export * from "./Helpers/NumberHelpers.ts";
+export * from "./Helpers/Permissions.ts";
+export * from "./Helpers/RichTextHelpers.ts";
+export * from "./Helpers/RowsStore.ts";
+export * from "./Helpers/TableHelpers.ts";
+export * from "./Helpers/TableStore.ts";
+export * from "./Helpers/ThemeHelpers.ts";
+export * from "./Helpers/TimeHelpers.ts";
+export * from "./Helpers/TreeStore.ts";
+export * from "./Helpers/ValidationHelpers.ts";
+export * from "./Interfaces/ApiInterfaces.ts";
+export * from "./Interfaces/CrudInterfaces.ts";
+export * from "./Interfaces/DateInterfaces.ts";
+export * from "./Interfaces/FormInterfaces.ts";
+export * from "./Interfaces/InputInterfaces.ts";
+export * from "./Interfaces/MessageInterfaces.ts";
+export * from "./Interfaces/TableInterfaces.ts";
+export * from "./Interfaces/ThemeInterfaces.ts";
+export * from "./Interfaces/TypeInterfaces.ts";

package/dist/Shared.Index.js

@@ -0,0 +1,47 @@
+// Works everywhere: server components, client components, and plain TypeScript.
+// Components
+export * from "./Components/Documents/Button.js";
+export * from "./Components/Inputs/Field.js";
+export * from "./Components/Layouts/ThemeScript.js";
+export * from "./Components/Viewers/MarkdownView.js";
+export * from "./Components/Viewers/RichTextView.js";
+// Helpers
+export * from "./Helpers/ApiClient.js";
+export * from "./Helpers/ApiFormHelpers.js";
+export * from "./Helpers/ApiModules.js";
+export * from "./Helpers/ApiResponses.js";
+export * from "./Helpers/ApiRoutes.js";
+export * from "./Helpers/ApiToasts.js";
+export * from "./Helpers/ClassHelpers.js";
+export * from "./Helpers/CrudBackend.js";
+export * from "./Helpers/CrudHelpers.js";
+export * from "./Helpers/DateHelpers.js";
+export * from "./Helpers/DateTimeHelpers.js";
+export * from "./Helpers/DropdownHelpers.js";
+export * from "./Helpers/FormDrafts.js";
+export * from "./Helpers/FormStore.js";
+export * from "./Helpers/InputParamsHelpers.js";
+export * from "./Helpers/MarkdownEditing.js";
+export * from "./Helpers/MarkdownHelpers.js";
+export * from "./Helpers/MessageBuilder.js";
+export * from "./Helpers/NepaliCalendar.js";
+export * from "./Helpers/NumberHelpers.js";
+export * from "./Helpers/Permissions.js";
+export * from "./Helpers/RichTextHelpers.js";
+export * from "./Helpers/RowsStore.js";
+export * from "./Helpers/TableHelpers.js";
+export * from "./Helpers/TableStore.js";
+export * from "./Helpers/ThemeHelpers.js";
+export * from "./Helpers/TimeHelpers.js";
+export * from "./Helpers/TreeStore.js";
+export * from "./Helpers/ValidationHelpers.js";
+// Interfaces
+export * from "./Interfaces/ApiInterfaces.js";
+export * from "./Interfaces/CrudInterfaces.js";
+export * from "./Interfaces/DateInterfaces.js";
+export * from "./Interfaces/FormInterfaces.js";
+export * from "./Interfaces/InputInterfaces.js";
+export * from "./Interfaces/MessageInterfaces.js";
+export * from "./Interfaces/TableInterfaces.js";
+export * from "./Interfaces/ThemeInterfaces.js";
+export * from "./Interfaces/TypeInterfaces.js";

package/package.json

@@ -1,33 +1,82 @@
-{
-  "name": "nexus-shared",
-  "version": "1.1.20",
-  "description": "Nexus shared React components for Next.js",
-  "type": "module",
-  "sideEffects": [
-    "**/*.css"
-  ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./client": "./src/client.ts",
-    "./interface": "./src/interface.ts"
-  },
-  "files": [
-    "src"
-  ],
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "peerDependencies": {
-    "react": "19.2.6",
-    "react-dom": "19.2.6",
-    "next": "16.2.6"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.15",
-    "@types/react-dom": "^19.2.3",
-    "typescript": "^5"
-  },
-  "dependencies": {
-    "dotenv": "^17.4.2"
-  }
-}
+{
+  "name": "nexus-shared",
+  "version": "2.0.0",
+  "description": "The Nexus component library for React and Next.js: params-driven inputs and forms, a data table with a CRUD on top, popups and toasts, an API layer with permissions, Markdown and rich text editors, and 7 themes in light and dark.",
+  "keywords": [
+    "react",
+    "nextjs",
+    "components",
+    "ui",
+    "forms",
+    "datatable",
+    "crud",
+    "inputs",
+    "design-system",
+    "typescript",
+    "nepali-calendar",
+    "nexus"
+  ],
+  "license": "MIT",
+  "author": "Bijay Adhikari",
+  "type": "module",
+  "sideEffects": [
+    "*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/Shared.Index.d.ts",
+      "default": "./dist/Shared.Index.js"
+    },
+    "./client": {
+      "types": "./dist/Client.Index.d.ts",
+      "default": "./dist/Client.Index.js"
+    },
+    "./server": {
+      "types": "./dist/Server.Index.d.ts",
+      "default": "./dist/Server.Index.js"
+    },
+    "./styles.css": "./src/Styles/Nexus.Index.css",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src/Styles"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node scripts/test-all.mjs",
+    "check:themes": "node scripts/check-themes.mjs",
+    "test:api": "node scripts/test-api.mts",
+    "test:dates": "node scripts/test-date-helpers.mts",
+    "test:datetimes": "node scripts/test-datetime-helpers.mts",
+    "test:drag": "node scripts/test-drag-helpers.mts",
+    "test:dropdown": "node scripts/test-dropdown-helpers.mts",
+    "test:forms": "node scripts/test-form-store.mts",
+    "test:markdown": "node scripts/test-markdown.mts",
+    "test:numbers": "node scripts/test-number-helpers.mts",
+    "test:popups": "node scripts/test-popup-rules.mts",
+    "test:richtext": "node scripts/test-richtext.mts",
+    "test:rows": "node scripts/test-rows-store.mts",
+    "test:table": "node scripts/test-table.mts",
+    "test:times": "node scripts/test-time-helpers.mts",
+    "test:tree": "node scripts/test-tree-store.mts",
+    "test:types": "tsc -p scripts/type-checks/tsconfig.json"
+  },
+  "dependencies": {
+    "nexus-icons": "^1.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-dom": ">=19"
+  },
+  "devDependencies": {
+    "@types/react": "19.3.0"
+  },
+  "engines": {
+    "node": ">=20.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Styles/Nexus.Base.css

@@ -0,0 +1,70 @@
+/* Page defaults and small shared utilities. */
+@layer nexus.base {
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+  }
+
+  body {
+    margin: 0;
+    background: var(--nx-bg);
+    color: var(--nx-text);
+    font: var(--nx-text-md) / var(--nx-leading) var(--nx-font);
+    -webkit-font-smoothing: antialiased;
+    text-rendering: optimizeLegibility;
+  }
+
+  button,
+  input,
+  select,
+  textarea {
+    font: inherit;
+    color: inherit;
+  }
+
+  /* Nepali text takes a font that has Devanagari glyphs, digits included. */
+  :lang(ne) {
+    font-family: var(--nx-font-devanagari);
+  }
+
+  :focus-visible {
+    outline: 2px solid var(--nx-primary);
+    outline-offset: 2px;
+  }
+
+  /* Hidden on screen but still read by screen readers and reachable with the keyboard. */
+  .nx-visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+  }
+
+  /* Icons sit on the text baseline and never shrink inside flex rows. */
+  .nx-icon {
+    flex-shrink: 0;
+    vertical-align: -0.125em;
+  }
+
+  .nx-spin {
+    animation: nx-spin 0.8s linear infinite;
+  }
+
+  @keyframes nx-spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .nx-spin {
+      animation-duration: 2.4s;
+    }
+  }
+}