nexus-shared 3.1.0 → 4.0.0

package/dist/Services/FileApi.js

@@ -0,0 +1,29 @@
+"use client";
+import { PrimaryPictures } from "../Helpers/FilePrimaries.js";
+import { NexusDriveAdapter } from "../Helpers/NexusDriveAdapter.js";
+import { api } from "./BrowserApi.js";
+/*
+ * The app's file backend and the page's kept pictures. Without a `defineFileAdapter`, the Nexus Drive through the app's
+ * `api` (its token, headers and proxy).
+ */
+/* The app's adapter */
+let current = null;
+/**
+ * Registers the app's file backend, once, beside its API modules. Without it, the Nexus Drive.
+ *
+ * @example
+ * defineFileAdapter(new NexusDriveAdapter({ client: api, drive: HrModule.Files }));
+ */
+export function defineFileAdapter(adapter) {
+    current = adapter;
+    primaryPictures.clear();
+    return adapter;
+}
+/** The registered file backend, or the Nexus Drive. */
+export function getFileAdapter() {
+    return (current ??= new NexusDriveAdapter({ client: api }));
+}
+/** Each owner's picture for the page's rows, read in one call per page and kept until a change on the page. */
+export const primaryPictures = new PrimaryPictures((module, category, ownerIds) => getFileAdapter().primaries(module, category, ownerIds, { toast: false }), {
+    batchSize: () => getFileAdapter().maxOwners,
+});

package/dist/Services/ImageEditorLoader.d.ts

@@ -0,0 +1,14 @@
+import type { ImageEditorModule } from "../Interfaces/FileInterfaces.ts";
+/**
+ * The image editor module, downloaded once per page. A failed download is not kept, so the next Edit tries again.
+ * Rejects with an `Error` in plain words ("The image editor is not installed on this server yet.", "The image editor
+ * could not be downloaded..."), and logs the cause (a network error, a 404, a bundler that rewrote the import) to the
+ * console, so a page that shows the message never hides why.
+ *
+ * @example
+ * const { openImageEditor } = await loadImageEditor();
+ * const picture = await openImageEditor({ src: file, aspect: 1, thumbnail: 256 });
+ */
+export declare function loadImageEditor(): Promise<ImageEditorModule>;
+/** Starts the download early, on the hover or focus of an Edit button, so the editor opens at once. Never rejects. */
+export declare function preloadImageEditor(): void;

package/dist/Services/ImageEditorLoader.js

@@ -0,0 +1,51 @@
+"use client";
+import { getFileAdapter } from "./FileApi.js";
+import { importModule } from "./ModuleImport.js";
+/*
+ * The image editor (`nexus-image-editor`, about 45 KB gzipped) is never in an app's bundle: the file backend serves it
+ * at a versioned address, and this loader downloads it the first time someone edits a picture. The address comes from
+ * the adapter (with Nexus, Drive's `Assets/File/nexus-image-editor.txt` names the current file), and the import is left
+ * alone by the bundler (`importModule`, ModuleImport.ts), so the module is fetched by the browser itself and cached by
+ * its immutable name.
+ */
+let loading = null;
+/** What a person reads when the module itself could not be downloaded or run: the cause goes to the console. */
+const NOT_DOWNLOADED = "The image editor could not be downloaded. Check the connection and try again; if it keeps failing, tell the site's support.";
+/**
+ * The image editor module, downloaded once per page. A failed download is not kept, so the next Edit tries again.
+ * Rejects with an `Error` in plain words ("The image editor is not installed on this server yet.", "The image editor
+ * could not be downloaded..."), and logs the cause (a network error, a 404, a bundler that rewrote the import) to the
+ * console, so a page that shows the message never hides why.
+ *
+ * @example
+ * const { openImageEditor } = await loadImageEditor();
+ * const picture = await openImageEditor({ src: file, aspect: 1, thumbnail: 256 });
+ */
+export function loadImageEditor() {
+    loading ??= getFileAdapter()
+        .editorModuleUrl()
+        .then(url => importModule(url).catch((cause) => {
+        console.error(`loadImageEditor(): ${url} could not be imported.`, cause);
+        throw new Error(NOT_DOWNLOADED);
+    }), (cause) => {
+        // The address could not be read: the adapter says why in plain words ("not installed on this server yet").
+        console.error("loadImageEditor(): the image editor's address could not be read.", cause);
+        throw cause instanceof Error && cause.message ? cause : new Error(NOT_DOWNLOADED);
+    })
+        .then(module => {
+        if (typeof module?.openImageEditor !== "function") {
+            console.error("loadImageEditor(): the module downloaded has no openImageEditor.", module);
+            throw new Error("The image editor on the server is not one this page can open.");
+        }
+        return module;
+    })
+        .catch((error) => {
+        loading = null;
+        throw error instanceof Error ? error : new Error(NOT_DOWNLOADED);
+    });
+    return loading;
+}
+/** Starts the download early, on the hover or focus of an Edit button, so the editor opens at once. Never rejects. */
+export function preloadImageEditor() {
+    loadImageEditor().catch(() => undefined);
+}

package/dist/Services/JoinSources.d.ts

@@ -0,0 +1,80 @@
+import { type CrudBackend } from "../Helpers/CrudBackend.ts";
+import type { ApiEndpoint } from "../Interfaces/ApiInterfaces.ts";
+import type { DropdownPage, DropdownPageRequest, OptionValue } from "../Interfaces/InputInterfaces.ts";
+import type { TableJoinSource, TableJoinedRecord } from "../Interfaces/TableInterfaces.ts";
+/**
+ * A join's source as the table calls it. An endpoint becomes one that POSTs the keys to it as an array and reads the
+ * records it answers - a Nexus controller's `findListing` - made once per endpoint, so every table and picker naming it
+ * shares one source and so one cache. A source of the page's own is used as it is.
+ *
+ * `key` is the field the records answered are filed under, `id` unless told: one whose values are another field (a
+ * person's account, which their company row carries beside its own key) is a source of its own, kept apart.
+ */
+export declare function joinSource(source: ApiEndpoint | TableJoinSource, backend?: CrudBackend, key?: string): TableJoinSource;
+/**
+ * The record a `findListing` answered for a key, or one the page remembered there (`TableJoins.remember`), at once and
+ * with no call, while it is fresh: `undefined` while it is not in, and once it was marked old (a save on that controller,
+ * a Reload), so a picker asks again and shows the record as it is now. A picker over that controller's records names a
+ * value with it (`peekOption`), and so does a CRUD's save, which takes an old one too (`aged`) over no name at all.
+ */
+export declare function peekFound(findListing: ApiEndpoint, key: string, aged?: boolean): TableJoinedRecord | undefined;
+/** The controller a picker offers records from: any with an `activeListing` and a `findListing` (`MODULES.controller(...)`). */
+export interface PickerController {
+    activeListing: ApiEndpoint;
+    findListing: ApiEndpoint;
+}
+/** What `crudPicker` needs to know of the records: the field a person reads, and the one under it. */
+export interface CrudPickerOptions {
+    /** The field shown as the option: `"regionName"`. */
+    labelKey: string;
+    /** A field shown under it, such as the parent's name: `"regionName"` under a sub-region. */
+    descriptionKey?: string;
+    /**
+     * The field that holds the value. Default `id`: the records' own key, which is what the controller's `findListing`
+     * takes. Another field - a person's account (`userId`), which their company row carries beside its own key - needs
+     * `find` for the values the kept list does not offer.
+     */
+    valueKey?: string;
+    /**
+     * Where a value the kept list does not offer is looked up when `valueKey` is not `id`: an endpoint that takes such
+     * values, POSTed as an array as `findListing` takes keys, and answers the records, each read by its `valueKey` field;
+     * or a source of the page's own. Its answers are kept apart from `findListing`'s and marked old with them, after a save
+     * on the controller. Without it such a value is never looked up - `findListing` could not answer it - so a form names it
+     * from the record it holds (`selectedOptions`), or it shows as not found.
+     */
+    find?: ApiEndpoint | TableJoinSource;
+    /**
+     * The query parameter the controller's `activeListing` narrows by on the server, for a picker another input narrows
+     * (`narrowedBy`): `"subscriptionGroupId"` asks `...?subscriptionGroupId={the group}` and keeps each answer apart. Without
+     * it, the whole list is read once and narrowed in the browser by the records' own field (`narrowedBy.key`).
+     */
+    narrowQuery?: string;
+    backend?: CrudBackend;
+}
+/** The dropdown params `crudPicker` gives: spread them into a dropdown's input. */
+export interface CrudPickerParams {
+    loadOptions: (request: DropdownPageRequest) => Promise<DropdownPage<TableJoinedRecord>>;
+    resolveOptions: (values: OptionValue[]) => Promise<readonly TableJoinedRecord[]>;
+    peekOption: (key: string, aged?: boolean) => TableJoinedRecord | undefined;
+    valueKey: string;
+    labelKey: string;
+    descriptionKey?: string;
+    isOptionInactive: (item: TableJoinedRecord) => boolean;
+}
+/**
+ * A dropdown of a controller's usable records, for picking a parent in a form: the `activeListing` read once and kept
+ * for every form on the page (the owner's caching rule: a second dropdown, or an Add row, never asks again), searched
+ * and paged in the browser. A value the form already holds that the list does not offer - a parent since trashed - is
+ * found through `findListing`, sharing the calls and answers of the tables' joins, and shows tagged, never offered again.
+ * A value that is not the records' key (`valueKey`) is found through the picker's own `find` instead.
+ *
+ * @example { type: EInputTypes.Dropdown, name: "regionId", label: "Region", required: true, ...crudPicker(REGIONS, { labelKey: "regionName" }) }
+ * @example crudPicker(COMPANY_USERS, { labelKey: "fullname", valueKey: "userId", find: COMPANY_USERS_BY_ACCOUNT })
+ */
+export declare function crudPicker(controller: PickerController, { labelKey, descriptionKey, valueKey, find, narrowQuery, backend }: CrudPickerOptions): CrudPickerParams;
+/**
+ * Marks what the page looked up from a controller as old, after a write there may have changed it: the records its
+ * `findListing` named and its pickers' own finds answered, and the list its picker offers. Drawn as they are until the
+ * next ask brings the new ones.
+ */
+export declare function expireLookups(controller: Partial<PickerController>): void;

package/dist/Services/JoinSources.js

@@ -0,0 +1,150 @@
+import { isApiEndpoint } from "../Helpers/ApiRoutes.js";
+import { getCrudBackend } from "../Helpers/CrudBackend.js";
+import { filterItems } from "../Helpers/DropdownHelpers.js";
+import { JOIN_LIFETIME, joinSourceName, tableJoins } from "../Helpers/TableJoins.js";
+import { api } from "./BrowserApi.js";
+/*
+ * The browser's half of a join: the call that looks records up, and a picker that shares what it looked up. The cache
+ * itself (`tableJoins`) knows nothing of the API; this is where an endpoint becomes a source it can call.
+ */
+const made = new Map();
+/** The sources of the pickers' own finds (`crudPicker` `find`), by the name of the `findListing` of their controller. */
+const finds = new Map();
+/** The lists a picker asked the server for, one per narrowing value (`narrowQuery`), by the name of their whole list. */
+const narrowedLists = new Map();
+/** A field with no value: what `narrow.orUnset` adds to a narrowed list. */
+const unset = (value) => value === null || value === undefined || value === "";
+/**
+ * A join's source as the table calls it. An endpoint becomes one that POSTs the keys to it as an array and reads the
+ * records it answers - a Nexus controller's `findListing` - made once per endpoint, so every table and picker naming it
+ * shares one source and so one cache. A source of the page's own is used as it is.
+ *
+ * `key` is the field the records answered are filed under, `id` unless told: one whose values are another field (a
+ * person's account, which their company row carries beside its own key) is a source of its own, kept apart.
+ */
+export function joinSource(source, backend = getCrudBackend(), key = "id") {
+    if (!isApiEndpoint(source))
+        return source;
+    const name = key === "id" ? joinSourceName(source) : `${joinSourceName(source)} by ${key}`;
+    let found = made.get(name);
+    if (!found) {
+        found = {
+            name,
+            ...(key !== "id" && { key }),
+            async load(keys, signal) {
+                const answer = await api.send(source, { body: keys, signal, toast: false });
+                if (!answer.ok)
+                    throw new Error(answer.message ?? "The records could not be looked up.");
+                return backend.readList(answer.result);
+            },
+        };
+        made.set(name, found);
+    }
+    return found;
+}
+/** What a source answered for a key, fresh, or - `aged` - also once it was marked old. */
+function peekSource(name, key, aged) {
+    if (!aged)
+        return tableJoins.peekFresh(name, key);
+    const state = tableJoins.peek(name, key);
+    return state.status === "ready" ? state.record : undefined;
+}
+/**
+ * The record a `findListing` answered for a key, or one the page remembered there (`TableJoins.remember`), at once and
+ * with no call, while it is fresh: `undefined` while it is not in, and once it was marked old (a save on that controller,
+ * a Reload), so a picker asks again and shows the record as it is now. A picker over that controller's records names a
+ * value with it (`peekOption`), and so does a CRUD's save, which takes an old one too (`aged`) over no name at all.
+ */
+export function peekFound(findListing, key, aged = false) {
+    return peekSource(joinSourceName(findListing), key, aged);
+}
+/**
+ * A dropdown of a controller's usable records, for picking a parent in a form: the `activeListing` read once and kept
+ * for every form on the page (the owner's caching rule: a second dropdown, or an Add row, never asks again), searched
+ * and paged in the browser. A value the form already holds that the list does not offer - a parent since trashed - is
+ * found through `findListing`, sharing the calls and answers of the tables' joins, and shows tagged, never offered again.
+ * A value that is not the records' key (`valueKey`) is found through the picker's own `find` instead.
+ *
+ * @example { type: EInputTypes.Dropdown, name: "regionId", label: "Region", required: true, ...crudPicker(REGIONS, { labelKey: "regionName" }) }
+ * @example crudPicker(COMPANY_USERS, { labelKey: "fullname", valueKey: "userId", find: COMPANY_USERS_BY_ACCOUNT })
+ */
+export function crudPicker(controller, { labelKey, descriptionKey, valueKey = "id", find, narrowQuery, backend = getCrudBackend() }) {
+    const listName = joinSourceName(controller.activeListing);
+    // Where a value the kept list does not offer is looked up: `findListing` while the values are the records' keys, the
+    // picker's own find for another field, and nowhere without one.
+    const lookup = find ? joinSource(find, backend, valueKey) : valueKey === "id" ? joinSource(controller.findListing, backend) : null;
+    if (find && lookup) {
+        // Marked old with the controller's own lookups, after a save there (`expireLookups`).
+        const beside = joinSourceName(controller.findListing);
+        const kept = finds.get(beside) ?? new Set();
+        kept.add(lookup.name);
+        finds.set(beside, kept);
+    }
+    // The words a person reads, not the key: a Nexus key is an encrypted token, and a search would find letters in it.
+    const searchKeys = descriptionKey ? [labelKey, descriptionKey] : [labelKey];
+    const loadList = (signal, query) => api.send(controller.activeListing, { signal, toast: false, ...(query && { query }) }).then(answer => {
+        if (!answer.ok)
+            throw new Error(answer.message ?? "The list could not be loaded.");
+        return backend.readList(answer.result);
+    });
+    /** The options narrowed by another input's value (`narrowedBy`): asked of the server by `narrowQuery`, else the kept list's. */
+    const narrowedList = async ({ key, value, orUnset }) => {
+        // The server narrows by a value; which records it adds for `orUnset` is its endpoint's rule.
+        if (narrowQuery && value !== null) {
+            const name = `${listName}?${narrowQuery}=${String(value)}`;
+            const kept = narrowedLists.get(listName) ?? new Set();
+            kept.add(name);
+            narrowedLists.set(listName, kept);
+            return tableJoins.list(name, signal => loadList(signal, { [narrowQuery]: String(value) }));
+        }
+        const all = await tableJoins.list(listName, loadList);
+        return all.filter(row => (value !== null && String(row[key]) === String(value)) || (orUnset && unset(row[key])));
+    };
+    return {
+        async loadOptions({ search, skip, pageSize, narrow }) {
+            const all = narrow ? await narrowedList(narrow) : await tableJoins.list(listName, loadList);
+            const matches = search ? filterItems(all, search, searchKeys) : all;
+            return { items: matches.slice(skip, skip + pageSize), total: matches.length, hasMore: skip + pageSize < matches.length };
+        },
+        // A saved value the kept list offers is named from it, with no call (a form opened on a tree's country); only one it
+        // does not offer - a parent since trashed - is looked up.
+        async resolveOptions(values) {
+            const keys = values.map(String);
+            const kept = tableJoins.peekList(listName) ?? [];
+            const found = kept.filter(row => keys.includes(String(row[valueKey])));
+            const missing = keys.filter(key => !found.some(row => String(row[valueKey]) === key));
+            if (missing.length === 0 || !lookup)
+                return found;
+            return [...found, ...(await tableJoins.records(lookup, missing))];
+        },
+        // The same at once, from what the page holds: a box named on its first draw, a saved record named with no call. Only
+        // what is fresh, unless an old record is asked for: a save names a value with one rather than with nothing.
+        peekOption(key, aged = false) {
+            const kept = tableJoins.peekList(listName, aged ? Infinity : JOIN_LIFETIME)?.find(row => String(row[valueKey]) === key);
+            return kept ?? (lookup ? peekSource(lookup.name, key, aged) : undefined);
+        },
+        valueKey,
+        labelKey,
+        ...(descriptionKey && { descriptionKey }),
+        isOptionInactive: item => !backend.isPickable(item),
+    };
+}
+/**
+ * Marks what the page looked up from a controller as old, after a write there may have changed it: the records its
+ * `findListing` named and its pickers' own finds answered, and the list its picker offers. Drawn as they are until the
+ * next ask brings the new ones.
+ */
+export function expireLookups(controller) {
+    if (controller.findListing) {
+        const name = joinSourceName(controller.findListing);
+        tableJoins.expire(name);
+        for (const other of finds.get(name) ?? [])
+            tableJoins.expire(other);
+    }
+    if (controller.activeListing) {
+        const name = joinSourceName(controller.activeListing);
+        tableJoins.expireList(name);
+        for (const narrowed of narrowedLists.get(name) ?? [])
+            tableJoins.expireList(narrowed);
+    }
+}

package/dist/Services/ModuleImport.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Imports an ES module by its full address, as the browser does, never through the app's bundler: a module a server
+ * serves at a versioned address (the image editor from the Nexus Drive).
+ *
+ * @example const editor = await importModule<ImageEditorModule>("https://drive.example/Assets/File/nexus-image-editor.3f2a.js");
+ */
+export declare function importModule<TModule>(url: string): Promise<TModule>;

package/dist/Services/ModuleImport.js

@@ -0,0 +1,22 @@
+/*
+ * The one dynamic `import()` of an address known only at run time, kept alone in this file on purpose.
+ *
+ * The package build rewrites "./Button.tsx" to "./Button.js" (`rewriteRelativeImportExtensions`), and for an `import()`
+ * of a variable it does so at run time: it wraps the address in a helper call, `import(helper(url))`. The bundler-ignore
+ * comments are then inside a call, so Next's Turbopack no longer leaves the import alone: it compiles it to "Cannot find
+ * module as expression is too dynamic", and the image editor never loads in an app's production build. This file imports
+ * nothing, so it is built a second time without that rewrite (`tsconfig.build.module-import.json`, after the main build,
+ * in `npm run build`), and the published file keeps the plain `import(/* webpackIgnore: true *\/ ... url)` that webpack,
+ * Turbopack and Vite all leave to the browser. `scripts/test-dist-loader.mts` (in `npm test`) fails if it ever does not.
+ *
+ * Add no import to this file: the second build would leave a "./x.ts" in it unrewritten.
+ */
+/**
+ * Imports an ES module by its full address, as the browser does, never through the app's bundler: a module a server
+ * serves at a versioned address (the image editor from the Nexus Drive).
+ *
+ * @example const editor = await importModule<ImageEditorModule>("https://drive.example/Assets/File/nexus-image-editor.3f2a.js");
+ */
+export function importModule(url) {
+    return import(/* webpackIgnore: true */ /* turbopackIgnore: true */ /* @vite-ignore */ url);
+}

package/dist/Services/ServerApi.d.ts

@@ -11,7 +11,12 @@ export interface ServerApiOptions {
 }
 /** 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. */
+    /**
+     * The app's own address, for `serverApi`'s relative roots and URLs such as `/api/…`, and for the X-Forwarded-Host and
+     * -Proto the proxy sends. Default: `URL_CURRENT` from the environment. Never a request's Host header as it came: a
+     * client can name any address in it, and `serverApi` would call that address. (The proxy calls a relative root at
+     * this server's own host and port, whatever this says.)
+     */
     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>;
@@ -35,9 +40,15 @@ export interface ServerApiConfig {
  * configureServerApi({ token: async () => (await cookies()).get("access_token")?.value });
  */
 export declare function configureServerApi(config: ServerApiConfig): void;
+/**
+ * The app's own address, as `configureServerApi({ origin })` or `URL_CURRENT` gives it; `undefined` when neither does.
+ * The proxy tells the backend it in X-Forwarded-Host and X-Forwarded-Proto.
+ */
+export declare function serverAppOrigin(): Promise<string | undefined>;
 /**
  * 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.
+ * set (API_RESERVATION)." when it is missing. `origin` resolves a relative root (the proxy passes this server's own);
+ * without it, the app's (`serverAppOrigin`).
  */
 export declare function serverModuleRoot(module: ApiModuleValue, origin?: string): Promise<string>;
 /**

package/dist/Services/ServerApi.js

@@ -12,21 +12,26 @@ let settings = {};
 export function configureServerApi(config) {
     settings = { ...settings, ...config };
 }
-async function appOrigin() {
+/**
+ * The app's own address, as `configureServerApi({ origin })` or `URL_CURRENT` gives it; `undefined` when neither does.
+ * The proxy tells the backend it in X-Forwarded-Host and X-Forwarded-Proto.
+ */
+export async function serverAppOrigin() {
     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());
+    const origin = fallbackOrigin ?? (await serverAppOrigin());
     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.
+ * set (API_RESERVATION)." when it is missing. `origin` resolves a relative root (the proxy passes this server's own);
+ * without it, the app's (`serverAppOrigin`).
  */
 export async function serverModuleRoot(module, origin) {
     return absolute(await getApiModules().serverUrl(module), origin);

package/dist/Shared.Index.d.ts

@@ -1,7 +1,9 @@
 export * from "./Components/Documents/Button.tsx";
+export * from "./Components/Documents/PrintDocument.tsx";
 export * from "./Components/Inputs/Field.tsx";
 export * from "./Components/Layouts/ThemeScript.tsx";
 export * from "./Components/Viewers/MarkdownView.tsx";
+export * from "./Components/Viewers/QrCodeImage.tsx";
 export * from "./Components/Viewers/RichTextView.tsx";
 export * from "./Helpers/ApiClient.ts";
 export * from "./Helpers/ApiFormHelpers.ts";
@@ -14,26 +16,42 @@ export * from "./Helpers/ChatHelpers.ts";
 export * from "./Helpers/ChatStore.ts";
 export * from "./Helpers/ChatSummaries.ts";
 export * from "./Helpers/ClassHelpers.ts";
+export * from "./Helpers/CodeHelpers.ts";
 export * from "./Helpers/CrudBackend.ts";
+export * from "./Helpers/CrudColumns.ts";
+export * from "./Helpers/CrudDetailsTabs.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/FileAdapter.ts";
+export * from "./Helpers/FilePrimaries.ts";
+export * from "./Helpers/NexusDriveAdapter.ts";
+export * from "./Helpers/FormConfirm.ts";
 export * from "./Helpers/FormDrafts.ts";
 export * from "./Helpers/FormStore.ts";
 export * from "./Helpers/InputParamsHelpers.ts";
+export * from "./Helpers/InputConditions.ts";
+export * from "./Helpers/InputNarrowing.ts";
+export * from "./Helpers/CrudNarrowPick.ts";
+export * from "./Helpers/CrudScopes.ts";
+export * from "./Helpers/CrudRowForms.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/QrCode.ts";
+export * from "./Helpers/RecordCards.ts";
+export * from "./Helpers/RequestCache.ts";
 export * from "./Helpers/RichTextHelpers.ts";
 export * from "./Helpers/RowsStore.ts";
 export * from "./Helpers/TableFilters.ts";
 export * from "./Helpers/TableHelpers.ts";
+export * from "./Helpers/TableJoins.ts";
 export * from "./Helpers/TableStore.ts";
 export * from "./Helpers/ThemeHelpers.ts";
 export * from "./Helpers/TimeHelpers.ts";
@@ -44,10 +62,12 @@ export * from "./Interfaces/ChatInterfaces.ts";
 export * from "./Interfaces/CrudInterfaces.ts";
 export * from "./Interfaces/DateInterfaces.ts";
 export * from "./Interfaces/ExcelInterfaces.ts";
+export * from "./Interfaces/FileInterfaces.ts";
 export * from "./Interfaces/FormInterfaces.ts";
 export * from "./Interfaces/InputInterfaces.ts";
 export * from "./Interfaces/MessageInterfaces.ts";
 export * from "./Interfaces/PreferenceInterfaces.ts";
+export * from "./Interfaces/RecordInterfaces.ts";
 export * from "./Interfaces/TableInterfaces.ts";
 export * from "./Interfaces/ThemeInterfaces.ts";
 export * from "./Interfaces/TypeInterfaces.ts";

package/dist/Shared.Index.js

@@ -1,9 +1,11 @@
 // Works everywhere: server components, client components, and plain TypeScript.
 // Components
 export * from "./Components/Documents/Button.js";
+export * from "./Components/Documents/PrintDocument.js";
 export * from "./Components/Inputs/Field.js";
 export * from "./Components/Layouts/ThemeScript.js";
 export * from "./Components/Viewers/MarkdownView.js";
+export * from "./Components/Viewers/QrCodeImage.js";
 export * from "./Components/Viewers/RichTextView.js";
 // Helpers
 export * from "./Helpers/ApiClient.js";
@@ -17,26 +19,42 @@ export * from "./Helpers/ChatHelpers.js";
 export * from "./Helpers/ChatStore.js";
 export * from "./Helpers/ChatSummaries.js";
 export * from "./Helpers/ClassHelpers.js";
+export * from "./Helpers/CodeHelpers.js";
 export * from "./Helpers/CrudBackend.js";
+export * from "./Helpers/CrudColumns.js";
+export * from "./Helpers/CrudDetailsTabs.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/FileAdapter.js";
+export * from "./Helpers/FilePrimaries.js";
+export * from "./Helpers/NexusDriveAdapter.js";
+export * from "./Helpers/FormConfirm.js";
 export * from "./Helpers/FormDrafts.js";
 export * from "./Helpers/FormStore.js";
 export * from "./Helpers/InputParamsHelpers.js";
+export * from "./Helpers/InputConditions.js";
+export * from "./Helpers/InputNarrowing.js";
+export * from "./Helpers/CrudNarrowPick.js";
+export * from "./Helpers/CrudScopes.js";
+export * from "./Helpers/CrudRowForms.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/QrCode.js";
+export * from "./Helpers/RecordCards.js";
+export * from "./Helpers/RequestCache.js";
 export * from "./Helpers/RichTextHelpers.js";
 export * from "./Helpers/RowsStore.js";
 export * from "./Helpers/TableFilters.js";
 export * from "./Helpers/TableHelpers.js";
+export * from "./Helpers/TableJoins.js";
 export * from "./Helpers/TableStore.js";
 export * from "./Helpers/ThemeHelpers.js";
 export * from "./Helpers/TimeHelpers.js";
@@ -48,10 +66,12 @@ export * from "./Interfaces/ChatInterfaces.js";
 export * from "./Interfaces/CrudInterfaces.js";
 export * from "./Interfaces/DateInterfaces.js";
 export * from "./Interfaces/ExcelInterfaces.js";
+export * from "./Interfaces/FileInterfaces.js";
 export * from "./Interfaces/FormInterfaces.js";
 export * from "./Interfaces/InputInterfaces.js";
 export * from "./Interfaces/MessageInterfaces.js";
 export * from "./Interfaces/PreferenceInterfaces.js";
+export * from "./Interfaces/RecordInterfaces.js";
 export * from "./Interfaces/TableInterfaces.js";
 export * from "./Interfaces/ThemeInterfaces.js";
 export * from "./Interfaces/TypeInterfaces.js";