nexus-shared 2.0.0 → 3.0.0

package/dist/Services/BrowserApi.d.ts

@@ -1,5 +1,5 @@
 import { type ConfirmOptions } from "../Components/Layouts/MessageBox.tsx";
-import { type ApiCall } from "../Helpers/ApiClient.ts";
+import { type ApiCall, type ApiResponseReader } from "../Helpers/ApiClient.ts";
 import { type ApiToastDefaults, type ApiToastOption } from "../Helpers/ApiToasts.ts";
 import type { ApiCallOptions, ApiResult, ApiTarget } from "../Interfaces/ApiInterfaces.ts";
 import type { DropdownItem, DropdownPage, DropdownPageRequest } from "../Interfaces/InputInterfaces.ts";
@@ -18,6 +18,12 @@ export interface BrowserApiConfig {
     credentials?: RequestCredentials;
     /** 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`.
+     * A call still reads its own with `read`. Registered once, it holds for calls the components make inside
+     * themselves too (`Crud`'s lists and actions, `ApiForm`'s save), which cannot be given one.
+     */
+    read?: ApiResponseReader<BrowserApiOptions>;
     /** Which toasts show when a call does not say. Default: errors always, successes for changes. */
     toast?: ApiToastDefaults;
     /** After a 401, or an expired token (Nexus error 2003), such as to send the user to sign in. The error toast shows too. */
@@ -30,6 +36,17 @@ export interface BrowserApiConfig {
  * settings they name. Nothing is needed when the proxy is at `/api/app` and the defaults suit.
  */
 export declare function configureApi(config: BrowserApiConfig): void;
+/**
+ * The app's default response reader, when it registered one (`configureApi({ read })`). For answers that did not come
+ * from a call and so have no client to read them: what an `ApiForm`'s own send function returned.
+ */
+export declare function getApiReader(): ApiResponseReader<BrowserApiOptions> | undefined;
+/**
+ * The app's call settings, for a request `api` cannot make: a download, which has to read the file's own bytes and the
+ * headers that name it, rather than an answer read as JSON. The headers, the token, and the cookie rule an app
+ * registered once belong on such a request too (`Services/ExcelApi.ts` is the one caller).
+ */
+export declare function getApiCallSettings(): BrowserApiConfig;
 /** Options of `api.confirm`: the call's, and changes to the question. */
 export type ConfirmApiOptions = ApiCallOptions & BrowserApiOptions & {
     question?: Partial<ConfirmOptions>;

package/dist/Services/BrowserApi.js

@@ -15,6 +15,21 @@ let settings = {};
 export function configureApi(config) {
     settings = { ...settings, ...config };
 }
+/**
+ * The app's default response reader, when it registered one (`configureApi({ read })`). For answers that did not come
+ * from a call and so have no client to read them: what an `ApiForm`'s own send function returned.
+ */
+export function getApiReader() {
+    return settings.read;
+}
+/**
+ * The app's call settings, for a request `api` cannot make: a download, which has to read the file's own bytes and the
+ * headers that name it, rather than an answer read as JSON. The headers, the token, and the cookie rule an app
+ * registered once belong on such a request too (`Services/ExcelApi.ts` is the one caller).
+ */
+export function getApiCallSettings() {
+    return settings;
+}
 /** Nexus error code for an expired token. */
 const TOKEN_EXPIRED = 2003;
 const TOAST_DURATION = 5000;
@@ -32,6 +47,9 @@ const config = {
     get credentials() {
         return settings.credentials;
     },
+    get read() {
+        return settings.read;
+    },
     dedupe: true,
     onStart(call) {
         const loading = planLoadingToast(call.context, call.options.toast);

package/dist/Services/ChatApi.d.ts

@@ -0,0 +1,37 @@
+import { type ChatBackend } from "../Helpers/ChatBackend.ts";
+import { ChatSummaryCache } from "../Helpers/ChatSummaries.ts";
+import type { ApiCallOptions } from "../Interfaces/ApiInterfaces.ts";
+import type { ChatDomainValue, ChatId, ChatPlaceSource, ChatScope, ChatSource, ChatSummary } from "../Interfaces/ChatInterfaces.ts";
+/** Options of one chat's source. */
+export interface ApiChatSourceOptions {
+    /** Which conversation at the place, when the record holds more than one. */
+    conversationId?: ChatId;
+    /** The backend to use, when it is not the app's registered one. */
+    backend?: ChatBackend<ChatDomainValue>;
+    /** Extras on every call this source makes, such as a header. */
+    call?: Omit<ApiCallOptions, "body" | "signal" | "params">;
+}
+/**
+ * A conversation's data through the app's API.
+ *
+ * @example
+ * const scope = { domain: EDomainTypes.Leave, parentId: leave.id, userId: me.id };
+ * const source = useMemo(() => apiChatSource(scope), [scope.domain, scope.parentId, scope.userId]);
+ */
+export declare function apiChatSource<TDomain extends ChatDomainValue>(scope: ChatScope<TDomain>, options?: ApiChatSourceOptions): ChatSource;
+/**
+ * The conversations a record holds, and how to start another.
+ *
+ * @example
+ * const place = useMemo(() => apiChatPlace(scope), [scope.domain, scope.parentId, scope.userId]);
+ */
+export declare function apiChatPlace<TDomain extends ChatDomainValue>(scope: ChatScope<TDomain>, options?: ApiChatSourceOptions): ChatPlaceSource;
+/** Asks the app's backend for many records' counts in one call. */
+export declare function loadChatSummaries(domain: ChatDomainValue, parentIds: readonly ChatId[], userId: ChatId): Promise<Map<string, ChatSummary>>;
+/**
+ * The counts every trigger icon on the page reads, filled in one call per domain however many icons there are. A page
+ * that already has the counts in its rows passes them to the icon instead, and never touches this.
+ */
+export declare function chatSummaries(): ChatSummaryCache;
+/** Replaces the page's count cache: a test's, or one with a different batching window. */
+export declare function defineChatSummaries(replacement: ChatSummaryCache): ChatSummaryCache;

package/dist/Services/ChatApi.js

@@ -0,0 +1,98 @@
+"use client";
+import { getChatBackend } from "../Helpers/ChatBackend.js";
+import { ChatSummaryCache } from "../Helpers/ChatSummaries.js";
+import { unwrapApiResult } from "../Helpers/ApiResponses.js";
+import { api } from "./BrowserApi.js";
+const callOptions = (options, signal) => ({ ...options?.call, ...(signal && { signal }), toast: false });
+/**
+ * A conversation's data through the app's API.
+ *
+ * @example
+ * const scope = { domain: EDomainTypes.Leave, parentId: leave.id, userId: me.id };
+ * const source = useMemo(() => apiChatSource(scope), [scope.domain, scope.parentId, scope.userId]);
+ */
+export function apiChatSource(scope, options) {
+    const backend = (options?.backend ?? getChatBackend());
+    const chat = options?.conversationId;
+    const source = {
+        async history(request) {
+            const answer = await api.send(backend.endpoint("history"), { ...callOptions(options, request.signal), body: backend.historyRequest(scope, request, chat) });
+            return backend.readHistory(unwrapApiResult(answer));
+        },
+        async send(draft, signal) {
+            const answer = await api.send(backend.endpoint("send"), { ...callOptions(options, signal), body: backend.sendRequest(scope, draft, chat) });
+            return backend.readMessage(unwrapApiResult(answer), scope, draft);
+        },
+    };
+    if (backend.supports("participants")) {
+        source.participants = async (query) => {
+            const answer = await api.send(backend.endpoint("participants"), { ...callOptions(options, query.signal), body: backend.participantsRequest(scope, query, chat) });
+            return backend.readParticipants(unwrapApiResult(answer));
+        };
+    }
+    if (backend.supports("addParticipants")) {
+        source.addParticipants = async (ids, signal) => {
+            const answer = await api.send(backend.endpoint("addParticipants"), { ...callOptions(options, signal), body: backend.addParticipantsRequest(scope, ids, chat) });
+            return backend.readParticipants(unwrapApiResult(answer)).items;
+        };
+    }
+    if (backend.supports("read")) {
+        source.markRead = async (upTo, signal) => {
+            unwrapApiResult(await api.send(backend.endpoint("read"), { ...callOptions(options, signal), body: backend.readMarkRequest(scope, upTo, chat) }));
+        };
+    }
+    if (backend.supports("remove")) {
+        source.remove = async (messageId, signal) => {
+            unwrapApiResult(await api.send(backend.endpoint("remove"), { ...callOptions(options, signal), params: backend.removeParams(scope, messageId) }));
+        };
+    }
+    return source;
+}
+/**
+ * The conversations a record holds, and how to start another.
+ *
+ * @example
+ * const place = useMemo(() => apiChatPlace(scope), [scope.domain, scope.parentId, scope.userId]);
+ */
+export function apiChatPlace(scope, options) {
+    const backend = (options?.backend ?? getChatBackend());
+    const place = {
+        async conversations(signal) {
+            const answer = await api.send(backend.endpoint("conversations"), { ...callOptions(options, signal), body: backend.conversationsRequest(scope) });
+            return backend.readConversations(unwrapApiResult(answer));
+        },
+    };
+    if (backend.supports("createConversation")) {
+        place.create = async (request, signal) => {
+            const answer = await api.send(backend.endpoint("createConversation"), { ...callOptions(options, signal), body: backend.createConversationRequest(scope, request) });
+            return backend.readConversation(unwrapApiResult(answer));
+        };
+    }
+    if (backend.supports("participants")) {
+        // Without a conversation, this asks who could be put in a new one here.
+        place.participants = async (query) => {
+            const answer = await api.send(backend.endpoint("participants"), { ...callOptions(options, query.signal), body: backend.participantsRequest(scope, query) });
+            return backend.readParticipants(unwrapApiResult(answer));
+        };
+    }
+    return place;
+}
+/** Asks the app's backend for many records' counts in one call. */
+export async function loadChatSummaries(domain, parentIds, userId) {
+    const backend = getChatBackend();
+    const answer = await api.send(backend.endpoint("summaries"), { body: backend.summariesRequest(domain, parentIds, userId), toast: false });
+    return backend.readSummaries(unwrapApiResult(answer));
+}
+let cache;
+/**
+ * The counts every trigger icon on the page reads, filled in one call per domain however many icons there are. A page
+ * that already has the counts in its rows passes them to the icon instead, and never touches this.
+ */
+export function chatSummaries() {
+    return (cache ??= new ChatSummaryCache({ load: loadChatSummaries }));
+}
+/** Replaces the page's count cache: a test's, or one with a different batching window. */
+export function defineChatSummaries(replacement) {
+    cache = replacement;
+    return replacement;
+}

package/dist/Services/ExcelApi.d.ts

@@ -0,0 +1,46 @@
+import type { ApiCallOptions, ApiResult } from "../Interfaces/ApiInterfaces.ts";
+import type { ExcelDownload, ExcelEndpoints, ExcelExportQuery, ExcelImportAnswer, ExcelSettings, ExcelSheetRow, ExcelVerifyAnswer } from "../Interfaces/ExcelInterfaces.ts";
+/** Options every spreadsheet call takes. */
+export interface ExcelCallOptions extends Pick<ApiCallOptions, "params" | "query" | "headers" | "signal" | "timeout" | "subject" | "read"> {
+    /** Shows no toast for this call. Default: a failure is told, a success is not (the panel says what happened). */
+    toast?: false;
+}
+/** Options of an export. Its `query` is what the person has on screen, not query-string values. */
+export interface ExcelExportOptions extends Omit<ExcelCallOptions, "query"> {
+    /** The search, the sort and the filters the person has on screen. */
+    query?: ExcelExportQuery;
+    /**
+     * Rows the search on screen leaves, when the page knows. Over the backend's limit, the person is asked first and
+     * told what will happen; without it, nothing is asked and the answer's own headers say what was left out.
+     */
+    rows?: number;
+    /** What one row is, for the question and the toast: "city". Default: the settings' subject. */
+    subject?: string;
+    /** Asks nothing, whatever the count. For a page that asked already. */
+    confirm?: false;
+}
+/**
+ * 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 declare function excelSettings(endpoints: ExcelEndpoints, options?: ExcelCallOptions): Promise<ApiResult<ExcelSettings>>;
+/** Forgets the kept settings, for a test or an app that changed what a sheet holds while it ran. */
+export declare function clearExcelSettings(): void;
+/** The template to fill in, as the backend built it, under the name the answer gives it. */
+export declare function downloadExcelTemplate(endpoints: ExcelEndpoints, options?: ExcelCallOptions): Promise<ApiResult<ExcelDownload>>;
+/**
+ * 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 declare function exportExcel(endpoints: ExcelEndpoints, options?: ExcelExportOptions): Promise<ApiResult<ExcelDownload> | null>;
+/** The filled file read and judged, with nothing written. The rows it answers with are what an import sends back. */
+export declare function verifyExcelFile(endpoints: ExcelEndpoints, file: File, options?: ExcelCallOptions): Promise<ApiResult<ExcelVerifyAnswer>>;
+/**
+ * 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 declare function importExcelRows(endpoints: ExcelEndpoints, rows: readonly ExcelSheetRow[], options?: ExcelCallOptions): Promise<ApiResult<ExcelImportAnswer>>;

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

@@ -1,4 +1,4 @@
-import { type ApiCall } from "../Helpers/ApiClient.ts";
+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 {
@@ -19,6 +19,11 @@ export interface ServerApiConfig {
     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;
 }

package/dist/Services/ServerApi.js

@@ -62,6 +62,9 @@ export const serverApi = createApiClient({
     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.

package/dist/Shared.Index.d.ts

@@ -9,12 +9,18 @@ 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";
@@ -33,8 +39,10 @@ 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";

package/dist/Shared.Index.js

@@ -12,12 +12,18 @@ 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";
@@ -37,8 +43,10 @@ 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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-shared",
-  "version": "2.0.0",
+  "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",
@@ -40,7 +40,8 @@
   },
   "files": [
     "dist",
-    "src/Styles"
+    "src/Styles",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -48,9 +49,11 @@
     "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",
@@ -64,7 +67,7 @@
     "test:types": "tsc -p scripts/type-checks/tsconfig.json"
   },
   "dependencies": {
-    "nexus-icons": "^1.0.0"
+    "nexus-icons": "^1.1.0"
   },
   "peerDependencies": {
     "react": ">=19",

package/src/Styles/Nexus.Button.css

@@ -20,6 +20,8 @@
     font-weight: 500;
     line-height: 1;
     white-space: nowrap;
+    /* The same classes make a link look like a button, for a call to action that navigates. */
+    text-decoration: none;
     cursor: pointer;
     user-select: none;
     box-shadow: var(--nx-shadow-sm);