nexus-shared 1.1.21 → 3.0.0

package/dist/Services/ExcelApi.js

@@ -0,0 +1,196 @@
+"use client";
+import { messageBox } from "../Components/Layouts/MessageBox.js";
+import { toast } from "../Components/Layouts/Toaster.js";
+import { apiCallContext } from "../Helpers/ApiClient.js";
+import { getExcelBackend, readDownloadHeaders, readExcelResponse } from "../Helpers/ExcelBackend.js";
+import { excelCount, excelExportWarning, excelText, saveExcelFile } from "../Helpers/ExcelHelpers.js";
+import { buildMessage } from "../Helpers/MessageBuilder.js";
+import { api, getApiCallSettings, getApiReader } from "./BrowserApi.js";
+/* The settings, kept */
+const settingsCache = new Map();
+const cacheKey = (endpoint, options) => `${String(endpoint.module)}|${endpoint.path}|${JSON.stringify(options.params ?? null)}`;
+/**
+ * The limits and the shape of the sheet. It is the same for everybody and changes once a release, so the first answer
+ * is kept for as long as the page lives - the backend says the same with a `Cache-Control` of an hour.
+ */
+export async function excelSettings(endpoints, options = {}) {
+    const key = cacheKey(endpoints.settings, options);
+    const kept = settingsCache.get(key);
+    if (kept)
+        return kept;
+    const asked = (async () => {
+        const answer = await api.get(endpoints.settings, { ...call(options), toast: options.toast === false ? false : { success: false } });
+        if (!answer.ok)
+            return answer;
+        return { ...answer, result: getExcelBackend().readSettings(answer.result) };
+    })();
+    settingsCache.set(key, asked);
+    // A failure is not worth keeping: the next offer of an import should ask again.
+    const answer = await asked;
+    if (!answer.ok)
+        settingsCache.delete(key);
+    return answer;
+}
+/** Forgets the kept settings, for a test or an app that changed what a sheet holds while it ran. */
+export function clearExcelSettings() {
+    settingsCache.clear();
+}
+/* The template, and the export: the two downloads */
+/** The template to fill in, as the backend built it, under the name the answer gives it. */
+export async function downloadExcelTemplate(endpoints, options = {}) {
+    const limits = await excelSettings(endpoints, { signal: options.signal, params: options.params, toast: options.toast });
+    const name = limits.result?.templateFileName ?? "template.xlsx";
+    const answer = await download(endpoints.template, options, name);
+    if (answer.ok && answer.result)
+        saveExcelFile(answer.result);
+    return answer;
+}
+/**
+ * An export of what the person has on screen: the search, the sort and the filters, sent to the model's own action.
+ * Not a file written from the rows the browser happens to hold - the backend writes every row the search leaves, up to
+ * its own limit, and says in the answer's headers what it left out.
+ *
+ * Over that limit the person is asked first, because a file that is quietly short is worse than one they chose.
+ */
+export async function exportExcel(endpoints, options = {}) {
+    const endpoint = endpoints.export;
+    if (!endpoint)
+        throw new Error("This model has no export endpoint: `excelEndpoints` was given `exportable: false`, or the app's own endpoints left `export` out.");
+    const limits = await excelSettings(endpoints, { signal: options.signal, params: options.params, toast: options.toast });
+    const subject = options.subject ?? limits.result?.subject ?? "row";
+    const limit = limits.result?.maxExportRows;
+    if (options.confirm !== false && limit !== undefined && options.rows !== undefined && options.rows > limit) {
+        const yes = await messageBox.confirm({
+            title: excelText("exportWarning"),
+            message: excelExportWarning(options.rows, limit, subject),
+            tone: "warning",
+            confirmLabel: `Export ${excelCount(limit, subject)}`,
+        });
+        if (!yes)
+            return null;
+    }
+    // The request is the model's own list request. A GET export carries it in the URL, a POST one in its body.
+    const request = getExcelBackend().exportRequest(options.query ?? {});
+    const isGet = endpoint.method === "GET";
+    const { query: _screen, ...rest } = options;
+    const answer = await download(endpoint, { ...rest, ...(isGet ? { query: toApiQuery(request) } : {}) }, `${subject}.xlsx`, isGet ? undefined : request);
+    if (!answer.ok || !answer.result)
+        return answer;
+    saveExcelFile(answer.result);
+    if (options.toast !== false) {
+        const note = answer.result.note;
+        const written = answer.result.rows === undefined ? undefined : excelCount(answer.result.rows, subject);
+        if (note)
+            toast.warning(written ? `${written} exported` : "Exported", { message: note });
+        else
+            toast.success(written ? `${written} exported` : "Exported", { message: answer.result.fileName });
+    }
+    return answer;
+}
+/* The two legs of an import */
+/** The filled file read and judged, with nothing written. The rows it answers with are what an import sends back. */
+export async function verifyExcelFile(endpoints, file, options = {}) {
+    const form = new FormData();
+    form.append(getExcelBackend().uploadField, file, file.name);
+    const answer = await api.post(endpoints.verify, form, { ...call(options), toast: options.toast === false ? false : { success: false } });
+    if (!answer.ok)
+        return answer;
+    return { ...answer, result: getExcelBackend().readVerify(answer.result) };
+}
+/**
+ * Writes the rows a verify answered with, as the person left them - the **rows**, never the file again, or every fix
+ * they made on screen would be lost. Every check runs again on the way in: what the browser sends is a row, not a
+ * decision.
+ */
+export async function importExcelRows(endpoints, rows, options = {}) {
+    const backend = getExcelBackend();
+    const answer = await api.post(endpoints.import, backend.importRequest(rows), { ...call(options), count: rows.length, toast: options.toast === false ? false : { success: false } });
+    // An import that wrote nothing at all is the one failure; it still answers with what it refused, where it says so.
+    return { ...answer, result: answer.result === undefined ? undefined : backend.readImport(answer.result) };
+}
+/* Inside */
+/**
+ * A call's options. The reader is named here, as the last word only: the call's own comes first and the app's
+ * (`configureApi({ read })`) second, so nothing shadows an app that registered one - and if neither did,
+ * `readExcelResponse` reads the backend's `errorMessages`, which is where a refused import says why.
+ */
+function call(options) {
+    const { toast: _toast, ...rest } = options;
+    return { ...rest, read: options.read ?? getApiReader() ?? readExcelResponse };
+}
+/** A request object as query values: what a URL can carry, and nothing else. */
+function toApiQuery(request) {
+    const query = {};
+    if (typeof request !== "object" || request === null)
+        return query;
+    for (const [key, value] of Object.entries(request)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value))
+            query[key] = value.filter(item => typeof item === "string" || typeof item === "number" || typeof item === "boolean");
+        else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date)
+            query[key] = value;
+    }
+    return query;
+}
+/**
+ * A download: the bytes, and the headers that say what the file is. It is the one `fetch` here, so it asks the API
+ * layer for everything a call of its own would have carried.
+ */
+async function download(endpoint, options, fallbackName, body) {
+    const settings = getApiCallSettings();
+    const described = apiCallContext(endpoint, { ...options, method: endpoint.method });
+    const url = await api.url(endpoint, { params: options.params, query: options.query, body });
+    const asked = { target: endpoint, ...described, url, options };
+    const headers = { ...settings.headers?.(asked), ...options.headers };
+    const token = settings.token?.(asked);
+    if (token)
+        headers.Authorization = /^bearer /i.test(token) ? token : `Bearer ${token}`;
+    if (body !== undefined)
+        headers["Content-Type"] = "application/json";
+    let response;
+    try {
+        response = await fetch(url, {
+            method: endpoint.method,
+            headers,
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            ...(settings.credentials ? { credentials: settings.credentials } : {}),
+            signal: options.signal,
+        });
+    }
+    catch (failure) {
+        // The caller gave up: nothing is said, as a stopped call says nothing anywhere else either.
+        if (failure instanceof DOMException && failure.name === "AbortError")
+            return { ok: false, aborted: true };
+        return fail({ ok: false, network: true }, described, options);
+    }
+    if (!response.ok)
+        return fail(await readFailure(response, options), described, options);
+    const blob = await response.blob();
+    // A file of nothing is not a file. Some proxies answer 200 with an empty body when the backend went away.
+    if (blob.size === 0)
+        return fail({ ok: false, status: response.status, message: buildMessage("failure", described.context) || undefined }, described, options);
+    return { ok: true, status: response.status, result: readDownloadHeaders(response.headers, blob, fallbackName) };
+}
+/** A refused download answers in the backend's own envelope, not with a file, so it is read as any other answer is. */
+async function readFailure(response, options) {
+    const read = options.read ?? getApiReader() ?? readExcelResponse;
+    const text = await response.text().catch(() => "");
+    let parsed = text;
+    if (text) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            // Not JSON: an HTML error page, or nothing. The reader words it from the status.
+        }
+    }
+    return read(parsed, response.status);
+}
+function fail(result, described, options) {
+    if (options.toast !== false && !result.aborted) {
+        const why = { ...described.context, status: result.status, network: result.network, timeout: result.timeout };
+        toast.error(buildMessage("failure", described.context) || excelText("verifyFailed"), { message: result.message || buildMessage("reason", why) || undefined });
+    }
+    return result;
+}

package/dist/Services/ServerApi.d.ts

@@ -0,0 +1,54 @@
+import { type ApiCall, type ApiResponseReader } 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;
+    /**
+     * Reads every answer, for a backend that does not answer as Nexus or ASP.NET Core do. Default `readApiResponse`.
+     * The same reader the browser is given in `configureApi`, so `api` and `serverApi` read one envelope.
+     */
+    read?: ApiResponseReader<ServerApiOptions>;
+    /** 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,78 @@
+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;
+    },
+    get read() {
+        return settings.read;
+    },
+    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,51 @@
+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/ChatBackend.ts";
+export * from "./Helpers/ChatHelpers.ts";
+export * from "./Helpers/ChatStore.ts";
+export * from "./Helpers/ChatSummaries.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/ExcelBackend.ts";
+export * from "./Helpers/ExcelHelpers.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/ChatInterfaces.ts";
+export * from "./Interfaces/CrudInterfaces.ts";
+export * from "./Interfaces/DateInterfaces.ts";
+export * from "./Interfaces/ExcelInterfaces.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,55 @@
+// 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/ChatBackend.js";
+export * from "./Helpers/ChatHelpers.js";
+export * from "./Helpers/ChatStore.js";
+export * from "./Helpers/ChatSummaries.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/ExcelBackend.js";
+export * from "./Helpers/ExcelHelpers.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/ChatInterfaces.js";
+export * from "./Interfaces/CrudInterfaces.js";
+export * from "./Interfaces/DateInterfaces.js";
+export * from "./Interfaces/ExcelInterfaces.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,85 @@
-{
-  "name": "nexus-shared",
-  "version": "1.1.21",
-  "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": "3.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",
+    "CHANGELOG.md"
+  ],
+  "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:chat": "node scripts/test-chat.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:excel": "node scripts/test-excel.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.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-dom": ">=19"
+  },
+  "devDependencies": {
+    "@types/react": "19.3.0"
+  },
+  "engines": {
+    "node": ">=20.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}