@antelopejs/interface-dms 0.3.5 → 0.4.0

package/dist/page/internal/layout-filter.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterLayoutHeaderActions = filterLayoutHeaderActions;
+exports.withComponentHeaderButtons = withComponentHeaderButtons;
+const button_availability_1 = require("../../base/internal/button-availability");
+const component_target_1 = require("./component-target");
+const permission_gate_1 = require("../../internal/permission-gate");
+async function serveHeaderButton(button, permissions, pagePermissionId, context) {
+    const { permission: _permission, permissionId: _permissionId, availability, ...served } = button;
+    if ((0, permission_gate_1.isPermissionGated)(button) &&
+        !(await (0, permission_gate_1.holdsPermissionGate)(await permissions(), button, pagePermissionId))) {
+        return undefined;
+    }
+    return (0, button_availability_1.applyButtonAvailability)(availability, served, context);
+}
+/**
+ * The page layout (the frame around the components) as one caller may see it:
+ * the header buttons whose gate the caller fails are left out — a `permission`
+ * names an action of the page, relative to `pagePermissionId` — and those
+ * whose `availability` refuses the request are disabled with its reason.
+ * `loadPermissions` is only called when a button declares a permission.
+ *
+ * @internal
+ */
+async function filterLayoutHeaderActions(layout, loadPermissions, context, pagePermissionId) {
+    const options = layout?.options;
+    const buttons = options?.headerActions;
+    if (!layout || !buttons)
+        return layout;
+    let loaded;
+    const permissions = () => (loaded ??= loadPermissions());
+    const served = await Promise.all(buttons.map((button) => serveHeaderButton(button, permissions, pagePermissionId, context)));
+    return {
+        ...layout,
+        options: {
+            ...options,
+            headerActions: served.filter((button) => button !== undefined),
+        },
+    };
+}
+const HEADER_PLACEMENT = "header";
+const ADD_BUTTON_LABEL = "$dms.table.new_row";
+const ADD_BUTTON_ICON = "i-ph-plus";
+const ADD_BUTTON_COLOR = "primary";
+/** The header buttons one component of the page places there. */
+function componentHeaderButtons(componentId, component) {
+    const options = (component.options ?? {});
+    const buttons = (options.customButtons ?? [])
+        .filter((button) => button.placement === HEADER_PLACEMENT)
+        .map(({ id, target: _target, placement: _placement, ...button }, index) => ({
+        ...button,
+        id: `${componentId}:${id ?? index}`,
+        componentId,
+        buttonId: id,
+    }));
+    const add = options.rowActions?.add;
+    if (typeof add === "object" && add.placement === HEADER_PLACEMENT) {
+        if (add.isEnabled === false)
+            return buttons;
+        buttons.push({
+            id: `${componentId}:add`,
+            label: add.label ?? ADD_BUTTON_LABEL,
+            icon: add.icon ?? ADD_BUTTON_ICON,
+            color: ADD_BUTTON_COLOR,
+            componentId,
+        });
+    }
+    return buttons;
+}
+/**
+ * The header buttons a component and its descendants place there, each named
+ * by the id the frontend renders it under: a table view nested in a tab or a
+ * card runs its buttons as one at the root of the page does.
+ */
+function treeHeaderButtons(clientId, component) {
+    const nested = (component.children ?? []).flatMap((child) => treeHeaderButtons((0, component_target_1.childComponentClientId)(clientId, child.id), child.component));
+    return [...componentHeaderButtons(clientId, component), ...nested];
+}
+/**
+ * The layout with, after its own header buttons, those the components of the
+ * page place in the header (`placement: "header"`): served as the components
+ * were, so a button whose permission the caller lacks is already gone, and a
+ * disabled one keeps its reason. The component still runs them: the header
+ * names it.
+ *
+ * @internal
+ */
+function withComponentHeaderButtons(layout, components) {
+    const placed = Object.entries(components).flatMap(([id, component]) => treeHeaderButtons(id, component));
+    if (!layout || placed.length === 0)
+        return layout;
+    const options = (layout.options ?? {});
+    return {
+        ...layout,
+        options: {
+            ...options,
+            headerActions: [...(options.headerActions ?? []), ...placed],
+        },
+    };
+}
+//# sourceMappingURL=layout-filter.js.map

package/dist/page/internal/layout-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-filter.js","sourceRoot":"","sources":["../../../src/page/internal/layout-filter.ts"],"names":[],"mappings":"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"}

package/dist/page/{metadata-helpers.d.ts → internal/metadata-helpers.d.ts}

@@ -1,4 +1,7 @@
-import { type PageInfo } from "./types";
+import { type PageInfo } from "../types";
+/** @internal */
 export declare const RequestTenantIdProperty: () => import("@antelopejs/interface-core/decorators").PropertyDecorator & import("@antelopejs/interface-core/decorators").ParameterDecorator;
+/** @internal */
 export declare function isPageInsideModule(pageInfo: PageInfo): boolean;
+/** @internal */
 export declare function logModuleRouteGated(fullSlug: string): void;

package/dist/page/{metadata-helpers.js → internal/metadata-helpers.js}

@@ -1,4 +1,9 @@
 "use strict";
+// The request-tenant decorator and the two module route guards: telling whether
+// a page lives inside a module, and logging once that a route was blocked for
+// that reason.
+//
+// Split out of metadata.ts.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestTenantIdProperty = void 0;
 exports.isPageInsideModule = isPageInsideModule;
@@ -6,15 +11,27 @@ exports.logModuleRouteGated = logModuleRouteGated;
 const interface_api_1 = require("@antelopejs/interface-api");
 const decorators_1 = require("@antelopejs/interface-core/decorators");
 const logging_1 = require("@antelopejs/interface-core/logging");
-const request_tenant_1 = require("../request-tenant");
-const types_1 = require("./types");
+// Import from the defining leaf, not the dms-base barrel: the barrel pulls in
+// table-view, which imports the page interface back — entering through the
+// barrel would then call DefaultLayout() while the barrel is still
+// mid-evaluation.
+const request_tenant_1 = require("../../request-tenant");
+// Deliberate and documented above: categories resolve controller
+// classes through PageMetadata, and metadata registers pages
+// through the proxies declared in categories. Neither module
+// dereferences the other while it evaluates.
+// oxlint-disable-next-line import/no-cycle
+const types_1 = require("../types");
+/** @internal */
 exports.RequestTenantIdProperty = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, index) => {
     (0, interface_api_1.SetParameterProvider)(target, key, index, (ctx) => (0, request_tenant_1.getRequestTenantId)(ctx));
 });
+/** @internal */
 function isPageInsideModule(pageInfo) {
     return pageInfo.fullSlug.startsWith(`${types_1.MODULE_URL_PREFIX}/`);
 }
 const loggedModuleSlugs = new Set();
+/** @internal */
 function logModuleRouteGated(fullSlug) {
     if (loggedModuleSlugs.has(fullSlug))
         return;

package/dist/page/internal/metadata-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-helpers.js","sourceRoot":"","sources":["../../../src/page/internal/metadata-helpers.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,8EAA8E;AAC9E,eAAe;AACf,EAAE;AACF,4BAA4B;;;AA6B5B,gDAEC;AAKD,kDAIC;AAtCD,6DAGmC;AACnC,sEAA0F;AAC1F,gEAA6D;AAC7D,8EAA8E;AAC9E,2EAA2E;AAC3E,mEAAmE;AACnE,kBAAkB;AAClB,yDAA0D;AAC1D,iEAAiE;AACjE,6DAA6D;AAC7D,6DAA6D;AAC7D,6CAA6C;AAC7C,2CAA2C;AAC3C,oCAA4D;AAC5D,gBAAgB;AACH,QAAA,uBAAuB,GAAG,IAAA,8CAAiC,EACtE,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE;IACrB,IAAA,oCAAoB,EAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,GAAmB,EAAE,EAAE,CAC/D,IAAA,mCAAkB,EAAC,GAAG,CAAC,CACxB,CAAC;AACJ,CAAC,CACF,CAAC;AAEF,gBAAgB;AAChB,SAAgB,kBAAkB,CAAC,QAAkB;IACnD,OAAO,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,GAAG,yBAAiB,GAAG,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;AAE5C,gBAAgB;AAChB,SAAgB,mBAAmB,CAAC,QAAgB;IAClD,IAAI,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAE,OAAO;IAC5C,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChC,iBAAO,CAAC,IAAI,CAAC,sBAAsB,QAAQ,uBAAuB,CAAC,CAAC;AACtE,CAAC"}

package/dist/page/internal/nav-badges.d.ts

@@ -0,0 +1,17 @@
+import type { RequestContext } from "@antelopejs/interface-api";
+import type { User } from "../../auth/db";
+/**
+ * Page full id → the navigation badge shown next to its entry.
+ *
+ * @internal
+ */
+export type NavBadges = Record<string, string>;
+/**
+ * The navigation badges of the pages `pageFullIds` — those the caller can
+ * open — for the caller of `ctx`: a table view tab declared with `navBadge`
+ * publishes its counter for its page. A count the caller may not read, one
+ * that fails, and a count of zero show no badge.
+ *
+ * @internal Called by the DMS when it serves the menu.
+ */
+export declare function ResolveNavBadges(ctx: RequestContext, user: User, pageFullIds: Set<string>): Promise<NavBadges>;

package/dist/page/internal/nav-badges.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveNavBadges = ResolveNavBadges;
+const interface_core_1 = require("@antelopejs/interface-core");
+const component_target_1 = require("./component-target");
+const metadata_1 = require("../metadata");
+const registry_1 = require("./registry");
+/** A component and everything it nests, each once. */
+function componentsUnder(root) {
+    const seen = new Set();
+    const walk = (component) => {
+        if (seen.has(component))
+            return;
+        seen.add(component);
+        for (const child of (0, component_target_1.getDeclaredComponentChildren)(component)) {
+            walk(child.component);
+        }
+    };
+    walk(root);
+    return [...seen];
+}
+function targetPageFullId(source, ownPageFullId) {
+    if (!source.page)
+        return ownPageFullId;
+    return (0, interface_core_1.GetMetadata)(source.page, metadata_1.PageMetadata).pageInfo?.fullId;
+}
+/** Every badge the registered pages publish, the first one for a page. */
+function publishedNavBadges(pageFullIds) {
+    const published = new Map();
+    for (const [ownPageFullId, meta] of registry_1.pageMetadataByFullId) {
+        const sources = Object.values(meta.components)
+            .flatMap(componentsUnder)
+            .flatMap((component) => component.navBadgeSources ?? []);
+        for (const source of sources) {
+            const pageFullId = targetPageFullId(source, ownPageFullId);
+            if (!pageFullId || !pageFullIds.has(pageFullId))
+                continue;
+            if (!published.has(pageFullId)) {
+                published.set(pageFullId, { pageFullId, source });
+            }
+        }
+    }
+    return [...published.values()];
+}
+/**
+ * The navigation badges of the pages `pageFullIds` — those the caller can
+ * open — for the caller of `ctx`: a table view tab declared with `navBadge`
+ * publishes its counter for its page. A count the caller may not read, one
+ * that fails, and a count of zero show no badge.
+ *
+ * @internal Called by the DMS when it serves the menu.
+ */
+async function ResolveNavBadges(ctx, user, pageFullIds) {
+    const counted = await Promise.allSettled(publishedNavBadges(pageFullIds).map(async ({ pageFullId, source }) => {
+        const count = await source.count(ctx, user);
+        return [pageFullId, count];
+    }));
+    const badges = {};
+    for (const result of counted) {
+        if (result.status !== "fulfilled")
+            continue;
+        const [pageFullId, count] = result.value;
+        if (count > 0)
+            badges[pageFullId] = String(count);
+    }
+    return badges;
+}
+//# sourceMappingURL=nav-badges.js.map

package/dist/page/internal/nav-badges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav-badges.js","sourceRoot":"","sources":["../../../src/page/internal/nav-badges.ts"],"names":[],"mappings":"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"}

package/dist/page/internal/page-registration.d.ts

@@ -0,0 +1,29 @@
+import type { User } from "../../auth/db";
+import { RoleModel, TenantMemberModel } from "../../db";
+/** @internal */
+export interface RouteCallbackContext {
+    user: User;
+    memberModel: TenantMemberModel;
+    roleModel: RoleModel;
+    tenantId: string;
+}
+/**
+ * What one registration of a page created, and how to take it back down.
+ *
+ * Registering scatters state across the page registry, the navigation tree,
+ * the permission tree, the layout handlers, the API routes and the realtime
+ * topics. Holding the undo of each next to the thing that made it turns
+ * teardown from a list somebody has to remember into a loop — and makes it
+ * impossible to add a registry to the path without saying how it is released.
+ *
+ * @internal
+ */
+export declare class PageRegistration {
+    private readonly disposers;
+    track(dispose: () => void): void;
+    /**
+     * Undo in reverse, and keep going when one step throws: a teardown that
+     * stops halfway leaves more behind than the error it reported.
+     */
+    dispose(): void;
+}

package/dist/page/internal/page-registration.js

@@ -0,0 +1,41 @@
+"use strict";
+// What a page registration created and how to undo it: the route callback
+// context and the registry of layouts to replay.
+//
+// Split out of metadata.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRegistration = void 0;
+const logging_1 = require("@antelopejs/interface-core/logging");
+/**
+ * What one registration of a page created, and how to take it back down.
+ *
+ * Registering scatters state across the page registry, the navigation tree,
+ * the permission tree, the layout handlers, the API routes and the realtime
+ * topics. Holding the undo of each next to the thing that made it turns
+ * teardown from a list somebody has to remember into a loop — and makes it
+ * impossible to add a registry to the path without saying how it is released.
+ *
+ * @internal
+ */
+class PageRegistration {
+    disposers = [];
+    track(dispose) {
+        this.disposers.push(dispose);
+    }
+    /**
+     * Undo in reverse, and keep going when one step throws: a teardown that
+     * stops halfway leaves more behind than the error it reported.
+     */
+    dispose() {
+        for (const dispose of this.disposers.splice(0).reverse()) {
+            try {
+                dispose();
+            }
+            catch (error) {
+                logging_1.Logging.Warn(`[DMS] Page teardown step failed: ${String(error)}`);
+            }
+        }
+    }
+}
+exports.PageRegistration = PageRegistration;
+//# sourceMappingURL=page-registration.js.map

package/dist/page/internal/page-registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-registration.js","sourceRoot":"","sources":["../../../src/page/internal/page-registration.ts"],"names":[],"mappings":";AAAA,0EAA0E;AAC1E,iDAAiD;AACjD,EAAE;AACF,4BAA4B;;;AAE5B,gEAA6D;AAoB7D;;;;;;;;;;GAUG;AACH,MAAa,gBAAgB;IACV,SAAS,GAAsB,EAAE,CAAC;IAE5C,KAAK,CAAC,OAAmB;QAC9B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;YACzD,IAAI,CAAC;gBACH,OAAO,EAAE,CAAC;YACZ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,iBAAO,CAAC,IAAI,CAAC,oCAAoC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;IACH,CAAC;CACF;AApBD,4CAoBC"}

package/dist/page/internal/registry.d.ts

@@ -0,0 +1,128 @@
+import type { ControllerClass } from "@antelopejs/interface-api";
+import type { Component } from "../../component";
+import type { PageMetadata } from "../metadata";
+import type { CategoryInfo, DynamicMenuProviderInfo, ModuleInfo, PageExtensionInfo, PageInfo, PageLayoutHandler } from "../types";
+/** @internal */
+export declare const permissionMap: Map<ControllerClass | Component<unknown>, string>;
+/** @internal */
+export declare const pageLayoutHandlers: Map<string, PageLayoutHandler>;
+/** @internal */
+export declare const pageMetadataByFullId: Map<string, PageMetadata>;
+/**
+ * Token-based identity for one family of registrations.
+ *
+ * Two things need it. Comparing a registration the implementation handed back
+ * against one held here cannot use `===`, and `RegisteringProxy` keys its own
+ * bookkeeping by object reference — so a caller unregistering with the view it
+ * holds would match nothing and silently leave the registration live. The
+ * token survives the round trip, so it can stand in for the reference in the
+ * first case and lead back to it in the second.
+ *
+ * @internal
+ */
+export declare class RegistrationIdentity<T extends object> {
+    private readonly kind;
+    private readonly byToken;
+    constructor(kind: string);
+    private tokenOf;
+    /** Give a registration a fresh identity, replacing any it already carried. */
+    stamp(value: T): void;
+    /**
+     * Record the reference a registration is filed under, stamping it first if
+     * nothing else did. Re-stamping here would orphan the identity an earlier
+     * caller already handed out.
+     */
+    remember(value: T): void;
+    /**
+     * Drop a registration's reference once it is unregistered.
+     *
+     * Only the registration still holding the token forgets it: a hot reload
+     * files the replacement before the departing one unwinds, and letting the
+     * departing one delete would strand the live reference.
+     */
+    forget(value: T): void;
+    /**
+     * Resolve a registration back to the reference it was filed under.
+     *
+     * Returns the argument unchanged when it carries no token or names no live
+     * registration, so an unknown one still reaches the proxy and is refused
+     * there rather than here.
+     */
+    resolve(value: T): T;
+    /**
+     * Two absent registrations are not the same registration: the caller asks
+     * whether a known one matches, and "nothing matches nothing" would let a
+     * teardown claim something it never registered.
+     */
+    isSame(left: T | undefined, right: T | undefined): boolean;
+}
+/** @internal */
+export declare const pageIdentity: RegistrationIdentity<PageInfo>;
+/** @internal */
+export declare const categoryIdentity: RegistrationIdentity<CategoryInfo>;
+/** @internal */
+export declare const moduleIdentity: RegistrationIdentity<ModuleInfo>;
+/** @internal */
+export declare const dynamicMenuProviderIdentity: RegistrationIdentity<DynamicMenuProviderInfo>;
+/** @internal */
+export declare const pageExtensionIdentity: RegistrationIdentity<PageExtensionInfo>;
+/**
+ * Remember the context of the module registering `info`. Called from the
+ * registration itself, before the extension crosses into the DMS.
+ *
+ * @internal
+ */
+export declare function capturePageExtensionContext(info: PageExtensionInfo): void;
+/**
+ * Run `callback` as the module that registered `info`, so everything it
+ * registers is owned by, and released with, that module. Runs in the current
+ * context when the registering module is unknown.
+ *
+ * @internal
+ */
+export declare function runAsPageExtensionOwner<T>(info: PageExtensionInfo, callback: () => T): T;
+/** @internal */
+export declare function stampPageRegistration(pageInfo: PageInfo): void;
+/** @internal */
+export declare function isSamePageRegistration(left: PageInfo | undefined, right: PageInfo | undefined): boolean;
+/** @internal */
+export declare const pageExtensions: Map<string, PageExtensionInfo[]>;
+/**
+ * Whether `info` is still registered: an extension whose module went away is
+ * revoked before that module's context is invalidated, and must not be
+ * prepared in that context afterwards.
+ *
+ * @internal
+ */
+export declare function isPageExtensionRegistered(info: PageExtensionInfo): boolean;
+/**
+ * Whether the page is registered *and* done serializing its own components.
+ * Presence in `pageMetadataByFullId` only answers the first half: a page is
+ * published there before it has any component to anchor onto.
+ *
+ * @internal
+ */
+export declare function acceptsPageExtensions(targetFullId: string): boolean;
+/**
+ * One page extension still waiting for the page id it names to register.
+ *
+ * @internal
+ */
+export interface PendingPageExtension {
+    extensionName: string;
+    targetFullId: string;
+}
+/**
+ * Extensions whose target page no module has registered. An extension names its
+ * target by id, so a typo — or a module that is simply not deployed — is
+ * indistinguishable from a page that has yet to start; both surface here.
+ *
+ * @internal
+ */
+export declare function GetPendingPageExtensions(): PendingPageExtension[];
+/** @internal */
+export declare function syncTargetExtensions(targetFullId: string): Promise<void>;
+/** @internal */
+export declare const moduleRootCategories: Map<string, CategoryInfo>;
+/** @internal */
+export declare const moduleDefaultCategories: Map<string, CategoryInfo>;