@phis/ui 0.2.0 → 0.3.0

package/plugins/runtime-modules/core/messaging/data-providers.js

@@ -0,0 +1,119 @@
+import { PhisThreadKind, PhisThreadStatus } from "../../../../constants/threads";
+import { PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS } from "../../../../constants/thread-library-provider-keys";
+import { PHI_CORE_RUNTIME_MODULE_ID } from "../ids";
+/**
+ * The conversations a viewer is in, as a Table rather than as a Widget or a Collection of its own.
+ *
+ * Core's, like the conversation and its Reply: every Module that runs a kind of conversation lists it
+ * through this Provider, pinning `kind` with the Table's `fixedFilters` -- Support its requests, the
+ * conversations Module everything a person is in, an add-on its own.
+ *
+ * A listing that had been its own Widget would have reimplemented paging, filters, a toolbar, an empty
+ * state and a skeleton, and would still have been the one surface nobody else could replace. A
+ * Collection got rid of that but put a component back in its place: a row was drawn by a renderer this
+ * Module shipped, so every question about it -- which columns, in what order, how wide, sorted how --
+ * was answered in code a Site could only replace wholesale. A Table answers all of them in
+ * configuration, and the Site that wants the other answer gives it in the Builder.
+ *
+ * What is lost with the renderer is nothing the rows needed: a conversation is a subject, a kind, a
+ * state and a time, which is a row of cells and was drawn as one even when it was a card.
+ *
+ * `search` is false because the Core route has no text parameter, not because a listing would not want
+ * one. Saying so here is what keeps a search box from appearing over a query that cannot answer it, and
+ * `sorting` is "none" for the same reason: the route answers by last activity and offers no other order.
+ */
+export const PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS = [
+    {
+        key: PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS.table,
+        ownerModuleId: PHI_CORE_RUNTIME_MODULE_ID,
+        kind: "table",
+        executionMode: "live",
+        authoringMode: "none",
+        title: "Conversations",
+        description: "The conversations a viewer may see, newest activity first.",
+        resources: [
+            {
+                resourceKey: "inbox",
+                title: "Inbox",
+                description: "Every conversation this viewer is in, whichever kind it is.",
+                rowIdentityPath: "id",
+                // A row is a conversation, and opening it is the whole point of the page.
+                rowActivation: true,
+                /*
+                 * And one conversation is what a Reply opens on: the Reply Form reads its thread from the row the
+                 * conversation's action names, so nothing carries it into a hidden field beside the Form.
+                 */
+                recordRead: true,
+                // Unread among everything the listing matches, not only the page shown: what a footer says.
+                summaryFields: [{ key: "unread", title: "Unread", type: "number" }],
+                /*
+                 * `state` and `archived` are not on the Core row; the Provider computes both.
+                 *
+                 * A badge renders a name and not a flag, and a condition reads a value and not an arithmetic
+                 * expression -- so the two things a surface actually asks of the status arrive as a name and as
+                 * a yes. The status itself stays, because a filter is written against what the route takes.
+                 */
+                fields: [
+                    { key: "id", title: "ID", type: "number", required: true },
+                    { key: "subject", title: "Subject", type: "string" },
+                    { key: "kind", title: "Kind", type: "enum", options: [
+                            { value: String(PhisThreadKind.Direct), label: "Direct" },
+                            { value: String(PhisThreadKind.Group), label: "Group" },
+                            { value: String(PhisThreadKind.CrossGroup), label: "Between groups" },
+                            { value: String(PhisThreadKind.Support), label: "Support" },
+                        ] },
+                    { key: "status", title: "Status", type: "enum", options: [
+                            { value: String(PhisThreadStatus.Open), label: "Open" },
+                            { value: String(PhisThreadStatus.Archived), label: "Archived" },
+                        ] },
+                    { key: "state", title: "State", type: "enum", options: [
+                            { value: "unread", label: "New" },
+                            { value: "open", label: "Open" },
+                            { value: "archived", label: "Archived" },
+                        ] },
+                    { key: "archived", title: "Archived", type: "boolean" },
+                    { key: "unread", title: "Unread", type: "boolean" },
+                    { key: "latestMessageAt", title: "Last activity", type: "datetime" },
+                    { key: "updatedAt", title: "Changed", type: "datetime" },
+                    { key: "createdAt", title: "Started", type: "datetime" },
+                ],
+                query: {
+                    search: false,
+                    sorting: "none",
+                    pagination: "offset",
+                    /*
+                     * The three the Core route takes, and no fourth.
+                     *
+                     * `kind` is what a Site pins to make one listing: a Support page filters to Support
+                     * conversations without Support having to bring a listing of its own.
+                     */
+                    filterFields: ["kind", "status", "unreadOnly"],
+                },
+                /*
+                 * Archiving is not deleting, and reopening is why it need not be.
+                 *
+                 * One row carries the status, so archiving closes the conversation for everyone in it rather
+                 * than hiding it from one reader -- which is why it asks first and why the way back asks
+                 * nothing: the consequence reaches other people, and undoing it reaches them again.
+                 */
+                actions: [
+                    {
+                        key: "archive",
+                        title: "Archive",
+                        scope: "row",
+                        intent: "write",
+                        confirmation: "required",
+                        visibleWhen: { source: "row", valuePath: "archived", operator: "falsy" },
+                    },
+                    {
+                        key: "reopen",
+                        title: "Reopen",
+                        scope: "row",
+                        intent: "write",
+                        visibleWhen: { source: "row", valuePath: "archived", operator: "truthy" },
+                    },
+                ],
+            },
+        ],
+    },
+];

package/plugins/runtime-modules/core/messaging/forms.d.ts

@@ -0,0 +1,16 @@
+export declare const PHI_CORE_MESSAGING_FORMS: readonly [import("../../contracts").PhiRuntimeModuleFormDefinition];
+export declare const PHI_CORE_MESSAGING_FORM_HANDLER_DESCRIPTORS: {
+    key: `${string}/${string}`;
+    ownerModuleId: "@phis/ui/modules/core";
+    title: string;
+    phase: "submit";
+    handlerKey: "site.threads.reply";
+    category: "site";
+    transport: "relay";
+    method: "POST";
+    endpointKey: null;
+    upstreamPath: string;
+    csrfPath: null;
+    requiresCsrf: false;
+    credentialPolicy: "site-session";
+}[];

package/plugins/runtime-modules/core/messaging/forms.js

@@ -0,0 +1,145 @@
+import { createPhiFormLabelSetLoader } from "../../../../components/forms/shared-form-loaders";
+import { PHI_FORM_FIELD_PROVIDER_KEYS, PHI_FORM_UPLOAD_LABEL_KEYS, PHI_FORM_VALIDATION_PROVIDER_KEYS, createPhiSharedFormProviderKey, } from "../../../../components/forms/form-provider-contract";
+import { PHI_FORM_GRID_LAST_LINE } from "../../../../components/forms/form-descriptor-contract";
+import { definePhiRuntimeModuleForm } from "../../../../components/forms/form-registry";
+import { PHI_SHARED_FORM_IDS } from "../../../../components/forms/shared-form-ids";
+import { PHI_CMS_AREA_KEYS } from "../../../../constants/cms-areas";
+import { PhisThreadMessageFlag } from "../../../../constants/threads";
+import { PHI_CORE_RUNTIME_MODULE_ID } from "../ids";
+/*
+ * Answering a conversation, as Core's Form, for every Module that runs conversations.
+ *
+ * A Module brings a kind of conversation -- direct ones, a group's, Support's, an add-on's -- and places
+ * this Form for writing into one. It is meant for a dialog opened by the conversation's own Reply
+ * action: that action names the thread as its row, and the Form reads it from there (`recordOpen` with
+ * the thread inbox as its `source`), so nothing has to carry the thread into a hidden field beside it.
+ *
+ * What a placement decides is whether it offers an internal note. `internalAllowed` is a hidden field
+ * the placement fills through `formConfig.initialValues`; the choice of audience is shown only where it
+ * is set. Core writes `Internal` for Staff alone whatever arrives, so a placement that offers it to
+ * somebody who may not write one offers a choice that changes nothing -- the setting says where the
+ * question makes sense, not who may answer it.
+ */
+const LABEL_SET_KEY = "@phis/ui/modules/core/labels/form:thread-reply";
+const label = (key, fallback) => ({ kind: "label", key, fallback });
+const FULL_ROW = { start: 1, end: PHI_FORM_GRID_LAST_LINE };
+const FULL_WIDTH = { compact: FULL_ROW, medium: FULL_ROW, wide: FULL_ROW };
+const PHI_THREAD_REPLY_FORM_HANDLER_KEY = "site.threads.reply";
+/** The user Space a reply's files go into: the writer's own, which is the only place a person may write. */
+const PHI_THREAD_REPLY_SPACE = "user";
+const PHI_THREAD_REPLY_FORM_DESCRIPTOR = {
+    schemaVersion: 1,
+    key: PHI_SHARED_FORM_IDS.threadReply,
+    labelSetKey: LABEL_SET_KEY,
+    fields: [
+        {
+            key: "threadId",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden,
+            validation: [{
+                    providerKey: PHI_FORM_VALIDATION_PROVIDER_KEYS.required,
+                    message: label("replyThreadRequired", "Choose a conversation first."),
+                }],
+        },
+        // Set by the placement where it offers a note only the people working the conversation read.
+        { key: "internalAllowed", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+        /*
+         * The message's flags as Core spells them, relayed as they are: `0` for everyone in it,
+         * `PhisThreadMessageFlag.Internal` for the note. It starts on everyone after every send, so a note is
+         * a choice made for that note.
+         */
+        {
+            key: "messageFlags",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.segmented,
+            initialValue: "0",
+            options: [
+                { value: "0", label: label("audienceEveryone", "To everyone in it") },
+                { value: String(PhisThreadMessageFlag.Internal), label: label("audienceInternal", "Internal note") },
+            ],
+            visibleWhen: { source: "form", valuePath: "internalAllowed", operator: "truthy" },
+        },
+        {
+            key: "message",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.textarea,
+            label: label("reply", "Your message"),
+            placeholder: label("replyPlaceholder", "Write a message"),
+            config: { rows: 4 },
+            validation: [{
+                    providerKey: PHI_FORM_VALIDATION_PROVIDER_KEYS.required,
+                    message: label("replyRequired", "Write something before you send it."),
+                }],
+        },
+        /*
+         * The attachment narrows nothing the Site has not narrowed already: the kinds are what the writer's
+         * own Space accepts, which the control plane answers for. An area rather than a button, because a
+         * file is part of what a reply says.
+         */
+        {
+            key: "assetIds",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.upload,
+            placeholder: label("replyAttach", "Attach a file"),
+            config: { space: PHI_THREAD_REPLY_SPACE, presentation: "area" },
+        },
+    ],
+    // One column: a reply is written across the width of the dialog, its label above it.
+    layout: { gap: { compact: "sm", medium: "base" }, label: FULL_WIDTH, control: FULL_WIDTH },
+    submit: { label: label("replySend", "Send"), align: "end" },
+};
+const loadLabels = createPhiFormLabelSetLoader(() => import("./labels").then((module) => module.getPhiThreadReplyFormLabels), (labels) => ({
+    reply: labels.replyLabel,
+    replyPlaceholder: labels.replyPlaceholder,
+    replyRequired: labels.replyRequired,
+    replyThreadRequired: labels.replyThreadRequired,
+    audienceEveryone: labels.audienceEveryone,
+    audienceInternal: labels.audienceInternal,
+    replyAttach: labels.replyAttachLabel,
+    replySend: labels.replySendLabel,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.dropHint]: labels.replyAttachDropHint,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.tooMany]: labels.replyAttachTooMany,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.pending]: labels.replyAttachPending,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorGeneric]: labels.replyErrorGeneric,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorNetwork]: labels.replyErrorNetwork,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorTooLarge]: labels.replyErrorTooLarge,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorDuplicate]: labels.replyErrorDuplicate,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorTypeNotAllowed]: labels.replyErrorTypeNotAllowed,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorQuotaExceeded]: labels.replyErrorQuotaExceeded,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorSpaceUnavailable]: labels.replyErrorSpaceUnavailable,
+    [PHI_FORM_UPLOAD_LABEL_KEYS.errorStorageUnreachable]: labels.replyErrorStorageUnreachable,
+}));
+// Every Area: a conversation may be placed wherever a Site runs one.
+export const PHI_CORE_MESSAGING_FORMS = [
+    definePhiRuntimeModuleForm({
+        ownerModuleId: PHI_CORE_RUNTIME_MODULE_ID,
+        areas: PHI_CMS_AREA_KEYS,
+        formId: PHI_SHARED_FORM_IDS.threadReply,
+        version: 1,
+        flags: 0,
+        title: "Reply",
+        description: "Writes a message into a conversation, with whatever hangs on it.",
+        category: "forms",
+        tags: ["threads", "message"],
+        descriptor: PHI_THREAD_REPLY_FORM_DESCRIPTOR,
+        submitHandlerKey: PHI_THREAD_REPLY_FORM_HANDLER_KEY,
+        loadLabels,
+    }),
+];
+/*
+ * The conversation travels in the values, not in the path: a relay handler declares one static upstream
+ * path, and Core answers this at `/api/site/threads/messages`, reading the thread from the body.
+ */
+export const PHI_CORE_MESSAGING_FORM_HANDLER_DESCRIPTORS = [
+    {
+        key: createPhiSharedFormProviderKey("handler", "thread-reply"),
+        ownerModuleId: PHI_CORE_RUNTIME_MODULE_ID,
+        title: "Write into a conversation",
+        phase: "submit",
+        handlerKey: PHI_THREAD_REPLY_FORM_HANDLER_KEY,
+        category: "site",
+        transport: "relay",
+        method: "POST",
+        endpointKey: null,
+        upstreamPath: "/api/site/threads/messages",
+        csrfPath: null,
+        requiresCsrf: false,
+        credentialPolicy: "site-session",
+    },
+];

package/plugins/runtime-modules/core/messaging/labels.d.ts

@@ -0,0 +1,49 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../../gateway/tr";
+export declare function getPhiThreadReplyFormLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    replyLabel: string;
+    replyPlaceholder: string;
+    replyRequired: string;
+    replyThreadRequired: string;
+    audienceEveryone: string;
+    audienceInternal: string;
+    replyAttachLabel: string;
+    replyAttachDropHint: string;
+    replySendLabel: string;
+    replyAttachTooMany: string;
+    replyAttachPending: string;
+    replyErrorGeneric: string;
+    replyErrorNetwork: string;
+    replyErrorTooLarge: string;
+    replyErrorDuplicate: string;
+    replyErrorTypeNotAllowed: string;
+    replyErrorQuotaExceeded: string;
+    replyErrorSpaceUnavailable: string;
+    replyErrorStorageUnreachable: string;
+}>;
+export declare function getPhiThreadConversationLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    noThreadText: string;
+    loadingText: string;
+    emptyText: string;
+    subjectFallback: string;
+    olderLabel: string;
+    archivedLabel: string;
+    replyLabel: string;
+    participantsLabel: string;
+    internalLabel: string;
+    translateLabel: string;
+    originalLabel: string;
+    machineTranslationLabel: string;
+    redactedText: string;
+    withheldText: string;
+    systemAuthorLabel: string;
+    unnamedAuthorLabel: string;
+    feedback: {
+        errorTitle: string;
+        errorGeneric: string;
+        errorNetwork: string;
+        errorNotFound: string;
+        errorTranslation: string;
+    };
+}>;
+export type PhiThreadConversationLabels = Awaited<ReturnType<typeof getPhiThreadConversationLabels>>;

package/plugins/runtime-modules/core/messaging/labels.js

@@ -0,0 +1,149 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../../gateway/tr";
+import { definePhiRuntimeModuleLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../../gateway/label-set";
+import { PHI_CORE_RUNTIME_MODULE_IDENTITY } from "../ids";
+/*
+ * What a conversation and the reply to it say, wherever they are placed.
+ *
+ * Core's, because messaging is: every Module that runs conversations of its own kind -- direct ones,
+ * a group's, Support's, an add-on's -- places the same conversation and the same reply, and reads them
+ * in the same words. A Module says what its own Page is called; it does not say "Reply" again.
+ */
+const PHI_THREAD_CONVERSATION_LABEL_SET = definePhiRuntimeModuleLabelSet(PHI_CORE_RUNTIME_MODULE_IDENTITY, {
+    key: "widget:thread-conversation",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        no_thread_text: definePhiMessageLabel("Choose a conversation to read."),
+        loading_text: definePhiMessageLabel("Loading the conversation."),
+        empty_text: definePhiMessageLabel("Nothing has been said here yet."),
+        subject_fallback: "Conversation",
+        older_label: "Show earlier messages",
+        archived_label: "Archived",
+        /* The action in the conversation's heading that opens a reply. */
+        reply_label: "Reply",
+        /* Before the names of who is in it, beneath a heading that is the subject. */
+        participants_label: "In this conversation",
+        /*
+         * Said on the note itself rather than in a legend somewhere.
+         *
+         * Staff write internal notes in the same place they write to the requester, and the one thing that
+         * must never be in doubt is which of the two a message is. A marker on the message is the only
+         * place a person actually looks while writing the next one.
+         */
+        internal_label: "Internal note",
+        /*
+         * One word for the control, because there is one control.
+         *
+         * The target language is not asked for: it is the language this person is reading in, and the button
+         * only appears where that language can actually be produced. A picker beside every message would have
+         * been a second control on every row for the sake of reading one message in a third language.
+         */
+        translate_label: "Translate",
+        original_label: "Show the original",
+        /*
+         * Said on the translation, because an unmarked one reads as what the person wrote.
+         *
+         * A machine translation carries a register nobody chose, and a support agent answering a sentence a
+         * machine put there has to know that is what they are looking at. The language it came out of stands
+         * beside it as its own name, where the provider reported one -- not woven into a sentence, which would
+         * fix a word order that only holds in English.
+         */
+        machine_translation_label: "Machine translation",
+        translation_error_text: definePhiMessageLabel("The translation could not be fetched."),
+        redacted_text: definePhiMessageLabel("This message was withdrawn."),
+        withheld_text: definePhiMessageLabel("This message is not shown to you."),
+        system_author_label: "System",
+        /* A projection carries a display name or nothing; nothing is still somebody. */
+        unnamed_author_label: "Someone",
+        error_title: "That did not work",
+        error_generic: definePhiMessageLabel("The conversation could not be loaded."),
+        error_network: definePhiMessageLabel("The site could not be reached."),
+        error_not_found: definePhiMessageLabel("This conversation is not there, or is not yours to read."),
+    },
+});
+/**
+ * The reply, as a declared Form. Its upload refusals are here for the reason the Form's own wording is:
+ * a file that was too large says so in the reader's language, and the shared English default in
+ * `upload-form-control.tsx` is what a Form without a label set falls back to, not what this one shows.
+ */
+const PHI_THREAD_REPLY_FORM_LABEL_SET = definePhiRuntimeModuleLabelSet(PHI_CORE_RUNTIME_MODULE_IDENTITY, {
+    key: "form:thread-reply",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        reply_label: "Your message",
+        reply_placeholder: definePhiMessageLabel("Write a message"),
+        reply_required: definePhiMessageLabel("Write something before you send it."),
+        reply_thread_required: definePhiMessageLabel("Choose a conversation first."),
+        /*
+         * Who reads it, where the placement offers the choice. Said as who it reaches rather than as a
+         * setting, because that is the question the writer is answering.
+         */
+        audience_everyone: "To everyone in it",
+        audience_internal: "Internal note",
+        reply_attach_label: "Attach a file",
+        reply_attach_drop_hint: "or drop it here",
+        reply_send_label: "Send",
+        reply_attach_too_many: definePhiMessageLabel("No more files fit here."),
+        reply_attach_pending: definePhiMessageLabel("Wait until the file has arrived, then send."),
+        reply_error_generic: definePhiMessageLabel("The file could not be attached."),
+        reply_error_network: definePhiMessageLabel("The site could not be reached."),
+        reply_error_too_large: definePhiMessageLabel("That file is too large."),
+        reply_error_duplicate: definePhiMessageLabel("That file is already attached."),
+        reply_error_type_not_allowed: definePhiMessageLabel("That kind of file cannot be attached."),
+        reply_error_quota_exceeded: definePhiMessageLabel("There is no room left in your space."),
+        reply_error_space_unavailable: definePhiMessageLabel("Files cannot be attached on this site."),
+        reply_error_storage_unreachable: definePhiMessageLabel("The file storage could not be reached."),
+    },
+});
+export async function getPhiThreadReplyFormLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_THREAD_REPLY_FORM_LABEL_SET);
+    return {
+        replyLabel: labels.reply_label,
+        replyPlaceholder: labels.reply_placeholder,
+        replyRequired: labels.reply_required,
+        replyThreadRequired: labels.reply_thread_required,
+        audienceEveryone: labels.audience_everyone,
+        audienceInternal: labels.audience_internal,
+        replyAttachLabel: labels.reply_attach_label,
+        replyAttachDropHint: labels.reply_attach_drop_hint,
+        replySendLabel: labels.reply_send_label,
+        replyAttachTooMany: labels.reply_attach_too_many,
+        replyAttachPending: labels.reply_attach_pending,
+        replyErrorGeneric: labels.reply_error_generic,
+        replyErrorNetwork: labels.reply_error_network,
+        replyErrorTooLarge: labels.reply_error_too_large,
+        replyErrorDuplicate: labels.reply_error_duplicate,
+        replyErrorTypeNotAllowed: labels.reply_error_type_not_allowed,
+        replyErrorQuotaExceeded: labels.reply_error_quota_exceeded,
+        replyErrorSpaceUnavailable: labels.reply_error_space_unavailable,
+        replyErrorStorageUnreachable: labels.reply_error_storage_unreachable,
+    };
+}
+export async function getPhiThreadConversationLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_THREAD_CONVERSATION_LABEL_SET);
+    return {
+        noThreadText: labels.no_thread_text,
+        loadingText: labels.loading_text,
+        emptyText: labels.empty_text,
+        subjectFallback: labels.subject_fallback,
+        olderLabel: labels.older_label,
+        archivedLabel: labels.archived_label,
+        replyLabel: labels.reply_label,
+        participantsLabel: labels.participants_label,
+        internalLabel: labels.internal_label,
+        translateLabel: labels.translate_label,
+        originalLabel: labels.original_label,
+        machineTranslationLabel: labels.machine_translation_label,
+        redactedText: labels.redacted_text,
+        withheldText: labels.withheld_text,
+        systemAuthorLabel: labels.system_author_label,
+        unnamedAuthorLabel: labels.unnamed_author_label,
+        feedback: {
+            errorTitle: labels.error_title,
+            errorGeneric: labels.error_generic,
+            errorNetwork: labels.error_network,
+            errorNotFound: labels.error_not_found,
+            errorTranslation: labels.translation_error_text,
+        },
+    };
+}

package/plugins/runtime-modules/{threads/services/table.js → core/messaging/thread-inbox-table.js}

@@ -1,18 +1,12 @@
 "use client";
 import { PhisThreadStatus } from "../../../../constants/threads";
+import { buildPhiTablePageParams, createPhiTableProviderRequestInit, readPhiTableRows, } from "../../../../components/widgets/client/shared/phi-table-provider-request";
 import { PhiTableProviderError, } from "../../../../types/table-widget";
 import { createPhiTableProviderClient } from "../../../../components/widgets/client/shared/phi-table-provider";
 import { PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS } from "../../../../constants/thread-library-provider-keys";
-import { PHI_THREADS_RUNTIME_DATA_PROVIDER_DESCRIPTORS } from "../data-providers";
-import { PHI_THREADS_RUNTIME_DATA_PROVIDER_KEYS } from "../ids";
+import { PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS } from "./data-providers";
 import { readPhiTableProviderResponse, } from "../../../../components/widgets/client/shared/phi-table-provider-response";
 const API_PATH = "/api/site/threads";
-const requestInit = (signal) => ({
-    cache: "no-store",
-    credentials: "include",
-    headers: { accept: "application/json" },
-    signal,
-});
 const RESPONSE_OPTIONS = {
     subject: "Conversation",
     errorKeys: ["message", "error"],
@@ -30,10 +24,7 @@ function readIntegerFilter(query, key) {
  * nothing to sort by rather than offering a control that does nothing.
  */
 function buildThreadQuery(query) {
-    const search = new URLSearchParams({
-        page: String(query.page && query.page > 0 ? query.page : 1),
-        pageSize: String(query.pageSize && query.pageSize > 0 ? query.pageSize : 25),
-    });
+    const search = buildPhiTablePageParams(query);
     const kind = readIntegerFilter(query, "kind");
     const status = readIntegerFilter(query, "status");
     const unreadOnly = query.filters?.unreadOnly;
@@ -62,22 +53,19 @@ function readThreadRow(row) {
         state: archived ? "archived" : row.unread === true ? "unread" : "open",
     };
 }
-function readRows(value) {
-    return Array.isArray(value)
-        ? value.filter((row) => Boolean(row) && typeof row === "object" && !Array.isArray(row))
-        : [];
-}
 async function queryThreadTable({ resourceKey, query, signal, }) {
     if (resourceKey !== "inbox") {
         throw new PhiTableProviderError("resource-not-found", `Unknown conversation resource "${resourceKey}".`);
     }
-    const payload = await readPhiTableProviderResponse(await fetch(`${API_PATH}?${buildThreadQuery(query).toString()}`, requestInit(signal)), RESPONSE_OPTIONS);
-    const rows = readRows(payload?.rows).map(readThreadRow);
+    const payload = await readPhiTableProviderResponse(await fetch(`${API_PATH}?${buildThreadQuery(query).toString()}`, createPhiTableProviderRequestInit(signal)), RESPONSE_OPTIONS);
+    const rows = readPhiTableRows(payload?.rows).map(readThreadRow);
     return {
         rows,
         total: typeof payload?.total === "number" ? payload.total : rows.length,
         page: typeof payload?.page === "number" ? payload.page : undefined,
         pageSize: typeof payload?.pageSize === "number" ? payload.pageSize : undefined,
+        // Unread among everything the listing matches, for a footer beside the total.
+        summary: { unread: typeof payload?.unread === "number" ? payload.unread : 0 },
     };
 }
 function readThreadId(value) {
@@ -109,7 +97,7 @@ async function mutateThreadTable(request) {
     if (status == null) {
         throw new PhiTableProviderError("action-not-supported", `Unsupported conversation action "${request.actionKey}".`);
     }
-    const init = requestInit(request.signal);
+    const init = createPhiTableProviderRequestInit(request.signal);
     await readPhiTableProviderResponse(await fetch(`${API_PATH}/${readThreadId(request.rowIdentity)}`, {
         ...init,
         method: "PATCH",
@@ -118,13 +106,25 @@ async function mutateThreadTable(request) {
     }), RESPONSE_OPTIONS);
     return { status: "accepted", invalidation: "view" };
 }
+/**
+ * One conversation as the Reply Form starts from it: which thread, and nothing else. The row is all a
+ * Reply needs, so it is answered without a request -- whether the thread is there and the reader may
+ * write into it is the write's to answer, as it always is.
+ */
+async function readThreadRecord({ resourceKey, rowIdentity }) {
+    if (resourceKey !== "inbox") {
+        throw new PhiTableProviderError("invalid-resource", `Unknown conversation resource "${resourceKey}".`);
+    }
+    return { threadId: readThreadId(rowIdentity) };
+}
 // Found by key rather than by position, the way the groups Module does it: a Module declares more than
 // one Provider and the descriptor list is not an ordering anybody promised to keep.
-const resources = PHI_THREADS_RUNTIME_DATA_PROVIDER_DESCRIPTORS
-    .find((descriptor) => descriptor.key === PHI_THREADS_RUNTIME_DATA_PROVIDER_KEYS.inbox)?.resources ?? [];
+const resources = PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS
+    .find((descriptor) => descriptor.key === PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS.table)?.resources ?? [];
 export const PhiThreadTableProviderClient = createPhiTableProviderClient({
     key: PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS.table,
     resources,
     query: queryThreadTable,
+    readRecord: readThreadRecord,
     mutate: mutateThreadTable,
 });

package/plugins/runtime-modules/core/server.js

@@ -1,8 +1,10 @@
+import { PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS } from "../../../constants/core-data-provider-keys";
 import { PHI_CORE_RUNTIME_MODULE_THEMES } from "../area-base-presets";
 import { definePhiRuntimeModuleServerAreaContribution } from "../area-contributions";
 import { PHI_CORE_RUNTIME_MODULE_DEFINITION } from "./definition";
 import { PHI_RUNTIME_MODULE_LAYOUTS as PHI_CORE_LAYOUTS } from "./layouts";
 import { PHI_RUNTIME_MODULE_WIDGETS as PHI_CORE_WIDGETS } from "./widgets";
+import { PHI_CORE_MESSAGING_FORMS } from "./messaging/forms";
 /** The one module every Area carries. It owns no Page of its own, so it contributes no route. */
 export function createPhiCoreRuntimeModuleServerAreaContribution() {
     return definePhiRuntimeModuleServerAreaContribution({
@@ -10,11 +12,21 @@ export function createPhiCoreRuntimeModuleServerAreaContribution() {
         catalogEntry: {
             definition: PHI_CORE_RUNTIME_MODULE_DEFINITION,
             widgets: PHI_CORE_WIDGETS,
+            forms: PHI_CORE_MESSAGING_FORMS,
             layouts: PHI_CORE_LAYOUTS,
             themes: PHI_CORE_RUNTIME_MODULE_THEMES,
+            /*
+             * One Area only. Core reaches every Area there is, and a runtime figure is an operator's fact: on
+             * an App Dashboard it would be something a visitor can read and nobody can act on.
+             */
             dashboardCards: {
+                areas: ["admin"],
                 load: () => import("./cards").then((module) => module.PHI_CORE_RUNTIME_MODULE_DASHBOARD_CARDS),
             },
+            recordProviders: [{
+                    key: PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS.contentEntry,
+                    load: () => import("./content-entries/record.server").then((module) => module.resolvePhiContentEntryRecord),
+                }],
             load: () => import("./module").then((module) => module.PHI_CORE_RUNTIME_MODULE),
         },
     });

package/plugins/runtime-modules/core/widgets/account/client.js

@@ -120,10 +120,12 @@ export function PhiAccountWidgetClient({ runtime, avatarSrc, avatarAlt, contribu
             .then((avatar) => {
             setViewerAvatarSrc(avatar?.thumbnailUrl ?? avatar?.previewUrl ?? avatar?.deliveryUrl ?? null);
         })
-            .catch(() => {
-            // No picture is the ordinary answer, and a failed read is indistinguishable from it here. The
-            // initials carry the trigger either way.
-            setViewerAvatarSrc(null);
+            .catch((error) => {
+            // A failed read is not "no picture". The menu trigger has no line for an error, so the last
+            // picture it had stays, and the failure is written where an operator looks for it.
+            if (controller.signal.aborted)
+                return;
+            console.error("[phi-account-widget] The viewer's avatar could not be read.", error);
         });
         return () => controller.abort();
     }, [avatarRevision, state.kind]);

package/plugins/runtime-modules/core/widgets/account/config.d.ts

@@ -1,5 +1,5 @@
 import type { PhiAccountWidgetConfig } from "./client";
-export declare function parsePhiAccountWidgetConfig(rawConfig: Record<string, unknown> | null | undefined): PhiAccountWidgetConfig;
+declare function parsePhiAccountWidgetConfig(rawConfig: Record<string, unknown> | null | undefined): PhiAccountWidgetConfig;
 export declare const PHI_ACCOUNT_WIDGET_DEFINITION: {
     kind: "widget";
     pluginKey: string;
@@ -8,7 +8,9 @@ export declare const PHI_ACCOUNT_WIDGET_DEFINITION: {
     title: string;
     description: string;
     category: "navigation";
+    icon: string;
     iconFamily: string;
     fields: never[];
     parseConfig: typeof parsePhiAccountWidgetConfig;
 };
+export {};