@memberjunction/ng-entity-viewer 5.39.0 → 5.40.1

package/dist/lib/view-types/view-type.contracts.d.ts

@@ -0,0 +1,235 @@
+import { Type, EventEmitter } from '@angular/core';
+import { EntityInfo, IMetadataProvider } from '@memberjunction/core';
+/**
+ * View-Type Plugin Architecture — Contracts
+ * -----------------------------------------
+ * This file defines the framework-level contracts for the entity-viewer's pluggable
+ * view-type system. A "view type" is a way of rendering a set of entity records — the
+ * built-in ones being Grid, Cards, Timeline, and Map, with future additions like
+ * Cluster and Tag Cloud.
+ *
+ * The design separates three concerns:
+ *   1. {@link IViewTypeDescriptor} — metadata + availability + the component types to mount.
+ *      Descriptors are discovered at runtime via the {@link https MemberJunction ClassFactory}
+ *      keyed off the `DriverClass` stored in the `MJ: View Types` entity.
+ *   2. {@link IViewRenderer} — the contract a renderer component honors so the host can
+ *      feed it data and listen for selection/open/config events uniformly.
+ *   3. {@link IViewPropSheet} — the contract a configuration prop-sheet component honors.
+ *
+ * Because this lives in an Angular package, it is acceptable for the descriptor to reference
+ * Angular's `Type<T>` (it points at the concrete component classes to instantiate).
+ */
+/**
+ * Framework-agnostic-ish descriptor for a single view type.
+ *
+ * A descriptor is the bridge between the `MJ: View Types` metadata row (which stores
+ * the `DriverClass` name) and the concrete Angular components that actually render the
+ * view and edit its configuration. Descriptors are registered with the ClassFactory via
+ * `@RegisterClass(BaseViewTypeDescriptor, '<DriverClass>')` so they can be discovered by
+ * name without a hard import from the host.
+ */
+export interface IViewTypeDescriptor {
+    /**
+     * Stable internal key for the view type — matches the `DriverClass` column on the
+     * `MJ: View Types` entity and the `@RegisterClass` registration key
+     * (e.g. "GridViewType", "CardsViewType").
+     */
+    readonly Name: string;
+    /** User-facing label shown in the view-mode switcher (e.g. "Grid", "Tag Cloud"). */
+    readonly DisplayName: string;
+    /** Font Awesome icon class shown in the switcher (e.g. "fa-solid fa-table"). */
+    readonly Icon: string;
+    /**
+     * The Angular component class that renders this view type. The host instantiates /
+     * mounts this component and feeds it data per the {@link IViewRenderer} contract.
+     */
+    readonly RendererComponent: Type<unknown>;
+    /**
+     * Optional Angular component class for this view type's configuration prop-sheet
+     * (honors {@link IViewPropSheet}). Undefined when the view type has no configurable
+     * options.
+     */
+    readonly PropSheetComponent?: Type<unknown>;
+    /**
+     * Predicate that decides whether this view type is available for a given entity.
+     * For example, Timeline requires a date field; Map requires geocoding support.
+     * Grid and Cards are always available.
+     *
+     * @param entity the entity the viewer is currently displaying
+     * @param provider optional metadata provider (for multi-provider scenarios)
+     */
+    IsAvailableFor(entity: EntityInfo, provider?: IMetadataProvider): boolean;
+    /**
+     * Optional async hook to load any data this descriptor's {@link IsAvailableFor} predicate
+     * depends on (e.g. the Cluster view type needs the set of entities that have an active
+     * Entity Document with vectors). The host awaits this once — before computing availability —
+     * so the synchronous predicate can read from a now-populated cache. Implementations should
+     * be cheap/idempotent (typically `await SomeEngine.Instance.Config(false, ...)`). Omit when
+     * availability is computable purely from the {@link EntityInfo} (Grid/Cards/Timeline/Map).
+     *
+     * @param provider optional metadata provider (for multi-provider scenarios)
+     */
+    EnsureAvailabilityData?(provider?: IMetadataProvider): Promise<void>;
+}
+/**
+ * Contract honored by a view renderer component. The host binds these inputs and
+ * subscribes to these outputs uniformly across all view types.
+ *
+ * @typeParam TConfig the shape of this view type's configuration object
+ */
+export interface IViewRenderer<TConfig = unknown> {
+    /** The entity whose records are being rendered. */
+    entity: EntityInfo | null;
+    /** The records to render (already loaded/filtered by the host). */
+    records: Record<string, unknown>[];
+    /** Primary-key string of the currently selected record, if any. */
+    selectedRecordId: string | null;
+    /** Active filter text (for highlighting / client-side concerns). */
+    filterText: string | null;
+    /** View-type-specific configuration. */
+    config: TConfig;
+    /**
+     * Optional: the metadata provider, handed to plug-ins that issue their own data calls
+     * (multi-provider safety). Generic — not specific to any one view type.
+     */
+    provider?: IMetadataProvider | null;
+    /**
+     * Optional generic data-context the host supplies alongside {@link records}. These are
+     * universal "a view of records" concepts (counts, current page, loading) — NOT specific to any
+     * view type — so a renderer that paginates or shows a total can read them, and one that doesn't
+     * simply ignores them. The host owns the actual data fetch; these describe its current result.
+     */
+    totalRecordCount?: number;
+    /** One-based current page of {@link records} when the host is paginating. */
+    page?: number;
+    /** Page size the host is using. */
+    pageSize?: number;
+    /** Whether the host is currently (re)loading the record set. */
+    isLoading?: boolean;
+    /** Emitted when a record is selected (single click). Payload is the raw record object. */
+    recordSelected: EventEmitter<unknown>;
+    /**
+     * Emitted when THIS entity's record should be opened (double-click / open). Payload is the raw
+     * record. This is a NAVIGATION request — the only category of signal that legitimately bubbles
+     * to the outer app (routing lives there). Everything else a view does (export, add-to-list,
+     * delete, …) is self-contained in the plug-in via Generic dialogs and never bubbles up.
+     */
+    recordOpened: EventEmitter<unknown>;
+    /**
+     * Optional: NAVIGATION request to open a *related* record on a DIFFERENT entity (e.g. a
+     * foreign-key drill-through in a grid cell). Bubbles to the outer app for routing. Generic —
+     * the container forwards it without acting on it.
+     */
+    openRelatedRecordRequested?: EventEmitter<ViewRelatedRecordNavigation>;
+    /**
+     * Optional: NAVIGATION request to create a new record of the current entity (e.g. a grid's
+     * "New" button) — opening the create form is a routing concern owned by the outer app. Bubbles
+     * up; the container forwards it without acting on it.
+     */
+    createRecordRequested?: EventEmitter<void>;
+    /**
+     * Emitted when the renderer mutates its own opaque {@link config} (e.g. timeline date field,
+     * grid columns/sort/widths, map render mode). The container persists the blob verbatim against
+     * the active `ViewTypeID` and never inspects it. (Container ↔ plug-in coordination inside the
+     * Generic layer — NOT a signal that drives the outer app.)
+     */
+    configChanged: EventEmitter<TConfig>;
+    /**
+     * Optional: ask the container to (re)load the record set differently. The ONLY data-access
+     * channel a plug-in has, fully generic — the container honors the request (sort / page /
+     * load-all) without knowing which plug-in asked or why. A grid emits sort/page; a map emits
+     * `{ loadAll: true }`; a plug-in happy with the records it's given emits nothing. The container
+     * owns the actual `RunView`; no per-view-type branching. (Container ↔ plug-in coordination —
+     * NOT a signal that drives the outer app.)
+     */
+    dataRequest?: EventEmitter<ViewDataRequest>;
+}
+/**
+ * A generic, view-type-agnostic request from a renderer for the host to change how it loads the
+ * record set. Every field is optional; the host applies whatever is present. No field names a
+ * specific view type — these are universal data-access concepts.
+ */
+export interface ViewDataRequest {
+    /** Desired sort, applied to the host's RunView OrderBy. Empty/omitted clears sorting. */
+    sort?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+    /** One-based page to load (for paginated views). */
+    page?: number;
+    /** Page size to load. */
+    pageSize?: number;
+    /** When true, the host loads the full result set (up to its safety cap) instead of paginating. */
+    loadAll?: boolean;
+}
+/**
+ * A NAVIGATION request to open a record on a (possibly different) entity — the generic payload
+ * for {@link IViewRenderer.openRelatedRecordRequested}. Routing lives in the outer app, so this
+ * is one of the few signals that legitimately bubbles up. The container forwards it untouched.
+ */
+export interface ViewRelatedRecordNavigation {
+    /** The entity whose record should be opened. */
+    entityName: string;
+    /** The record's key — a composite-key string or the raw key value(s). Opaque to the container. */
+    recordKey: unknown;
+}
+/**
+ * Contract honored by a view-type configuration prop-sheet component.
+ *
+ * @typeParam TConfig the shape of the configuration object being edited
+ */
+export interface IViewPropSheet<TConfig = unknown> {
+    /** The entity the configuration applies to. */
+    entity: EntityInfo | null;
+    /** The current configuration being edited. */
+    config: TConfig;
+    /** Emitted when the user changes the configuration. */
+    configChange: EventEmitter<TConfig>;
+}
+/**
+ * Abstract base class for all view-type descriptors.
+ *
+ * Concrete descriptors extend this and register themselves with the ClassFactory:
+ *
+ * ```typescript
+ * @RegisterClass(BaseViewTypeDescriptor, 'GridViewType')
+ * export class GridViewType extends BaseViewTypeDescriptor {
+ *   readonly Name = 'GridViewType';
+ *   readonly DisplayName = 'Grid';
+ *   readonly Icon = 'fa-solid fa-table';
+ *   readonly RendererComponent = EntityDataGridComponent;
+ *   IsAvailableFor(): boolean { return true; }
+ * }
+ * ```
+ *
+ * The {@link ViewTypeEngine} resolves descriptors by `DriverClass` name using
+ * `MJGlobal.Instance.ClassFactory.CreateInstance(BaseViewTypeDescriptor, driverClass)`.
+ *
+ * NOTE: This class is registered with the ClassFactory itself (via subclasses) and is
+ * intentionally NOT decorated — only concrete subclasses carry `@RegisterClass`.
+ */
+export declare abstract class BaseViewTypeDescriptor implements IViewTypeDescriptor {
+    abstract readonly Name: string;
+    abstract readonly DisplayName: string;
+    abstract readonly Icon: string;
+    abstract readonly RendererComponent: Type<unknown>;
+    readonly PropSheetComponent?: Type<unknown>;
+    /**
+     * Default availability: available for every entity. Override in subclasses that have
+     * requirements (e.g. Timeline needs a date field, Map needs geocoding).
+     */
+    IsAvailableFor(_entity: EntityInfo, _provider?: IMetadataProvider): boolean;
+    /**
+     * Default: nothing to preload. Override in subclasses whose availability predicate needs
+     * async data (e.g. the Cluster view type loading which entities have Entity Documents).
+     */
+    EnsureAvailabilityData(_provider?: IMetadataProvider): Promise<void>;
+}
+/**
+ * Tree-shaking guard. Force-references {@link RegisterClass} so bundlers don't drop the
+ * decorator import in builds that only touch this contracts module. Concrete descriptor
+ * modules each carry their own `@RegisterClass` and load guard, but this keeps the base
+ * module self-consistent.
+ */
+export declare function LoadViewTypeContracts(): void;
+//# sourceMappingURL=view-type.contracts.d.ts.map

package/dist/lib/view-types/view-type.contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-type.contracts.d.ts","sourceRoot":"","sources":["../../../src/lib/view-types/view-type.contracts.ts"],"names":[],"mappings":"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"}

package/dist/lib/view-types/view-type.contracts.js

@@ -0,0 +1,51 @@
+import { RegisterClass } from '@memberjunction/global';
+/**
+ * Abstract base class for all view-type descriptors.
+ *
+ * Concrete descriptors extend this and register themselves with the ClassFactory:
+ *
+ * ```typescript
+ * @RegisterClass(BaseViewTypeDescriptor, 'GridViewType')
+ * export class GridViewType extends BaseViewTypeDescriptor {
+ *   readonly Name = 'GridViewType';
+ *   readonly DisplayName = 'Grid';
+ *   readonly Icon = 'fa-solid fa-table';
+ *   readonly RendererComponent = EntityDataGridComponent;
+ *   IsAvailableFor(): boolean { return true; }
+ * }
+ * ```
+ *
+ * The {@link ViewTypeEngine} resolves descriptors by `DriverClass` name using
+ * `MJGlobal.Instance.ClassFactory.CreateInstance(BaseViewTypeDescriptor, driverClass)`.
+ *
+ * NOTE: This class is registered with the ClassFactory itself (via subclasses) and is
+ * intentionally NOT decorated — only concrete subclasses carry `@RegisterClass`.
+ */
+export class BaseViewTypeDescriptor {
+    PropSheetComponent;
+    /**
+     * Default availability: available for every entity. Override in subclasses that have
+     * requirements (e.g. Timeline needs a date field, Map needs geocoding).
+     */
+    IsAvailableFor(_entity, _provider) {
+        return true;
+    }
+    /**
+     * Default: nothing to preload. Override in subclasses whose availability predicate needs
+     * async data (e.g. the Cluster view type loading which entities have Entity Documents).
+     */
+    async EnsureAvailabilityData(_provider) {
+        // no-op by default
+    }
+}
+/**
+ * Tree-shaking guard. Force-references {@link RegisterClass} so bundlers don't drop the
+ * decorator import in builds that only touch this contracts module. Concrete descriptor
+ * modules each carry their own `@RegisterClass` and load guard, but this keeps the base
+ * module self-consistent.
+ */
+export function LoadViewTypeContracts() {
+    // no-op; presence prevents tree-shaking of this module's side-effect-free exports
+    void RegisterClass;
+}
+//# sourceMappingURL=view-type.contracts.js.map

package/dist/lib/view-types/view-type.contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-type.contracts.js","sourceRoot":"","sources":["../../../src/lib/view-types/view-type.contracts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAmNvD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAgB,sBAAsB;IAKjC,kBAAkB,CAAiB;IAE5C;;;OAGG;IACH,cAAc,CAAC,OAAmB,EAAE,SAA6B;QAC/D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,sBAAsB,CAAC,SAA6B;QACxD,mBAAmB;IACrB,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB;IACnC,kFAAkF;IAClF,KAAK,aAAa,CAAC;AACrB,CAAC","sourcesContent":["import { Type, EventEmitter } from '@angular/core';\nimport { EntityInfo, IMetadataProvider } from '@memberjunction/core';\nimport { RegisterClass } from '@memberjunction/global';\n\n/**\n * View-Type Plugin Architecture — Contracts\n * -----------------------------------------\n * This file defines the framework-level contracts for the entity-viewer's pluggable\n * view-type system. A \"view type\" is a way of rendering a set of entity records — the\n * built-in ones being Grid, Cards, Timeline, and Map, with future additions like\n * Cluster and Tag Cloud.\n *\n * The design separates three concerns:\n *   1. {@link IViewTypeDescriptor} — metadata + availability + the component types to mount.\n *      Descriptors are discovered at runtime via the {@link https MemberJunction ClassFactory}\n *      keyed off the `DriverClass` stored in the `MJ: View Types` entity.\n *   2. {@link IViewRenderer} — the contract a renderer component honors so the host can\n *      feed it data and listen for selection/open/config events uniformly.\n *   3. {@link IViewPropSheet} — the contract a configuration prop-sheet component honors.\n *\n * Because this lives in an Angular package, it is acceptable for the descriptor to reference\n * Angular's `Type<T>` (it points at the concrete component classes to instantiate).\n */\n\n/**\n * Framework-agnostic-ish descriptor for a single view type.\n *\n * A descriptor is the bridge between the `MJ: View Types` metadata row (which stores\n * the `DriverClass` name) and the concrete Angular components that actually render the\n * view and edit its configuration. Descriptors are registered with the ClassFactory via\n * `@RegisterClass(BaseViewTypeDescriptor, '<DriverClass>')` so they can be discovered by\n * name without a hard import from the host.\n */\nexport interface IViewTypeDescriptor {\n  /**\n   * Stable internal key for the view type — matches the `DriverClass` column on the\n   * `MJ: View Types` entity and the `@RegisterClass` registration key\n   * (e.g. \"GridViewType\", \"CardsViewType\").\n   */\n  readonly Name: string;\n\n  /** User-facing label shown in the view-mode switcher (e.g. \"Grid\", \"Tag Cloud\"). */\n  readonly DisplayName: string;\n\n  /** Font Awesome icon class shown in the switcher (e.g. \"fa-solid fa-table\"). */\n  readonly Icon: string;\n\n  /**\n   * The Angular component class that renders this view type. The host instantiates /\n   * mounts this component and feeds it data per the {@link IViewRenderer} contract.\n   */\n  readonly RendererComponent: Type<unknown>;\n\n  /**\n   * Optional Angular component class for this view type's configuration prop-sheet\n   * (honors {@link IViewPropSheet}). Undefined when the view type has no configurable\n   * options.\n   */\n  readonly PropSheetComponent?: Type<unknown>;\n\n  /**\n   * Predicate that decides whether this view type is available for a given entity.\n   * For example, Timeline requires a date field; Map requires geocoding support.\n   * Grid and Cards are always available.\n   *\n   * @param entity the entity the viewer is currently displaying\n   * @param provider optional metadata provider (for multi-provider scenarios)\n   */\n  IsAvailableFor(entity: EntityInfo, provider?: IMetadataProvider): boolean;\n\n  /**\n   * Optional async hook to load any data this descriptor's {@link IsAvailableFor} predicate\n   * depends on (e.g. the Cluster view type needs the set of entities that have an active\n   * Entity Document with vectors). The host awaits this once — before computing availability —\n   * so the synchronous predicate can read from a now-populated cache. Implementations should\n   * be cheap/idempotent (typically `await SomeEngine.Instance.Config(false, ...)`). Omit when\n   * availability is computable purely from the {@link EntityInfo} (Grid/Cards/Timeline/Map).\n   *\n   * @param provider optional metadata provider (for multi-provider scenarios)\n   */\n  EnsureAvailabilityData?(provider?: IMetadataProvider): Promise<void>;\n}\n\n/**\n * Contract honored by a view renderer component. The host binds these inputs and\n * subscribes to these outputs uniformly across all view types.\n *\n * @typeParam TConfig the shape of this view type's configuration object\n */\nexport interface IViewRenderer<TConfig = unknown> {\n  /** The entity whose records are being rendered. */\n  entity: EntityInfo | null;\n\n  /** The records to render (already loaded/filtered by the host). */\n  records: Record<string, unknown>[];\n\n  /** Primary-key string of the currently selected record, if any. */\n  selectedRecordId: string | null;\n\n  /** Active filter text (for highlighting / client-side concerns). */\n  filterText: string | null;\n\n  /** View-type-specific configuration. */\n  config: TConfig;\n\n  /**\n   * Optional: the metadata provider, handed to plug-ins that issue their own data calls\n   * (multi-provider safety). Generic — not specific to any one view type.\n   */\n  provider?: IMetadataProvider | null;\n\n  /**\n   * Optional generic data-context the host supplies alongside {@link records}. These are\n   * universal \"a view of records\" concepts (counts, current page, loading) — NOT specific to any\n   * view type — so a renderer that paginates or shows a total can read them, and one that doesn't\n   * simply ignores them. The host owns the actual data fetch; these describe its current result.\n   */\n  totalRecordCount?: number;\n  /** One-based current page of {@link records} when the host is paginating. */\n  page?: number;\n  /** Page size the host is using. */\n  pageSize?: number;\n  /** Whether the host is currently (re)loading the record set. */\n  isLoading?: boolean;\n\n  /** Emitted when a record is selected (single click). Payload is the raw record object. */\n  recordSelected: EventEmitter<unknown>;\n\n  /**\n   * Emitted when THIS entity's record should be opened (double-click / open). Payload is the raw\n   * record. This is a NAVIGATION request — the only category of signal that legitimately bubbles\n   * to the outer app (routing lives there). Everything else a view does (export, add-to-list,\n   * delete, …) is self-contained in the plug-in via Generic dialogs and never bubbles up.\n   */\n  recordOpened: EventEmitter<unknown>;\n\n  /**\n   * Optional: NAVIGATION request to open a *related* record on a DIFFERENT entity (e.g. a\n   * foreign-key drill-through in a grid cell). Bubbles to the outer app for routing. Generic —\n   * the container forwards it without acting on it.\n   */\n  openRelatedRecordRequested?: EventEmitter<ViewRelatedRecordNavigation>;\n\n  /**\n   * Optional: NAVIGATION request to create a new record of the current entity (e.g. a grid's\n   * \"New\" button) — opening the create form is a routing concern owned by the outer app. Bubbles\n   * up; the container forwards it without acting on it.\n   */\n  createRecordRequested?: EventEmitter<void>;\n\n  /**\n   * Emitted when the renderer mutates its own opaque {@link config} (e.g. timeline date field,\n   * grid columns/sort/widths, map render mode). The container persists the blob verbatim against\n   * the active `ViewTypeID` and never inspects it. (Container ↔ plug-in coordination inside the\n   * Generic layer — NOT a signal that drives the outer app.)\n   */\n  configChanged: EventEmitter<TConfig>;\n\n  /**\n   * Optional: ask the container to (re)load the record set differently. The ONLY data-access\n   * channel a plug-in has, fully generic — the container honors the request (sort / page /\n   * load-all) without knowing which plug-in asked or why. A grid emits sort/page; a map emits\n   * `{ loadAll: true }`; a plug-in happy with the records it's given emits nothing. The container\n   * owns the actual `RunView`; no per-view-type branching. (Container ↔ plug-in coordination —\n   * NOT a signal that drives the outer app.)\n   */\n  dataRequest?: EventEmitter<ViewDataRequest>;\n}\n\n/**\n * A generic, view-type-agnostic request from a renderer for the host to change how it loads the\n * record set. Every field is optional; the host applies whatever is present. No field names a\n * specific view type — these are universal data-access concepts.\n */\nexport interface ViewDataRequest {\n  /** Desired sort, applied to the host's RunView OrderBy. Empty/omitted clears sorting. */\n  sort?: Array<{ field: string; direction: 'asc' | 'desc' }>;\n  /** One-based page to load (for paginated views). */\n  page?: number;\n  /** Page size to load. */\n  pageSize?: number;\n  /** When true, the host loads the full result set (up to its safety cap) instead of paginating. */\n  loadAll?: boolean;\n}\n\n/**\n * A NAVIGATION request to open a record on a (possibly different) entity — the generic payload\n * for {@link IViewRenderer.openRelatedRecordRequested}. Routing lives in the outer app, so this\n * is one of the few signals that legitimately bubbles up. The container forwards it untouched.\n */\nexport interface ViewRelatedRecordNavigation {\n  /** The entity whose record should be opened. */\n  entityName: string;\n  /** The record's key — a composite-key string or the raw key value(s). Opaque to the container. */\n  recordKey: unknown;\n}\n\n/**\n * Contract honored by a view-type configuration prop-sheet component.\n *\n * @typeParam TConfig the shape of the configuration object being edited\n */\nexport interface IViewPropSheet<TConfig = unknown> {\n  /** The entity the configuration applies to. */\n  entity: EntityInfo | null;\n\n  /** The current configuration being edited. */\n  config: TConfig;\n\n  /** Emitted when the user changes the configuration. */\n  configChange: EventEmitter<TConfig>;\n}\n\n/**\n * Abstract base class for all view-type descriptors.\n *\n * Concrete descriptors extend this and register themselves with the ClassFactory:\n *\n * ```typescript\n * @RegisterClass(BaseViewTypeDescriptor, 'GridViewType')\n * export class GridViewType extends BaseViewTypeDescriptor {\n *   readonly Name = 'GridViewType';\n *   readonly DisplayName = 'Grid';\n *   readonly Icon = 'fa-solid fa-table';\n *   readonly RendererComponent = EntityDataGridComponent;\n *   IsAvailableFor(): boolean { return true; }\n * }\n * ```\n *\n * The {@link ViewTypeEngine} resolves descriptors by `DriverClass` name using\n * `MJGlobal.Instance.ClassFactory.CreateInstance(BaseViewTypeDescriptor, driverClass)`.\n *\n * NOTE: This class is registered with the ClassFactory itself (via subclasses) and is\n * intentionally NOT decorated — only concrete subclasses carry `@RegisterClass`.\n */\nexport abstract class BaseViewTypeDescriptor implements IViewTypeDescriptor {\n  abstract readonly Name: string;\n  abstract readonly DisplayName: string;\n  abstract readonly Icon: string;\n  abstract readonly RendererComponent: Type<unknown>;\n  readonly PropSheetComponent?: Type<unknown>;\n\n  /**\n   * Default availability: available for every entity. Override in subclasses that have\n   * requirements (e.g. Timeline needs a date field, Map needs geocoding).\n   */\n  IsAvailableFor(_entity: EntityInfo, _provider?: IMetadataProvider): boolean {\n    return true;\n  }\n\n  /**\n   * Default: nothing to preload. Override in subclasses whose availability predicate needs\n   * async data (e.g. the Cluster view type loading which entities have Entity Documents).\n   */\n  async EnsureAvailabilityData(_provider?: IMetadataProvider): Promise<void> {\n    // no-op by default\n  }\n}\n\n/**\n * Tree-shaking guard. Force-references {@link RegisterClass} so bundlers don't drop the\n * decorator import in builds that only touch this contracts module. Concrete descriptor\n * modules each carry their own `@RegisterClass` and load guard, but this keeps the base\n * module self-consistent.\n */\nexport function LoadViewTypeContracts(): void {\n  // no-op; presence prevents tree-shaking of this module's side-effect-free exports\n  void RegisterClass;\n}\n"]}

package/dist/lib/view-types/view-type.engine.d.ts

@@ -0,0 +1,76 @@
+import { BaseEngine, EntityInfo, IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { MJViewTypeEntity } from '@memberjunction/core-entities';
+import { BaseViewTypeDescriptor, IViewTypeDescriptor } from './view-type.contracts';
+/**
+ * ViewTypeEngine
+ * --------------
+ * Loads the `MJ: View Types` metadata rows (active, ordered by Sequence) and, given an
+ * `EntityInfo`, returns the list of view-type descriptors that are AVAILABLE for that
+ * entity.
+ *
+ * "Available" means two things both hold:
+ *   1. The view type is active and seeded in `MJ: View Types`.
+ *   2. A descriptor is registered with the ClassFactory under the row's `DriverClass`
+ *      AND that descriptor's `IsAvailableFor(entity)` predicate returns true.
+ *
+ * This is intentionally Angular-free — it depends only on `@memberjunction/core`,
+ * `@memberjunction/global`, and `@memberjunction/core-entities` so it can run anywhere.
+ * It extends {@link BaseEngine} for automatic caching + entity-event auto-refresh.
+ */
+export declare class ViewTypeEngine extends BaseEngine<ViewTypeEngine> {
+    /**
+     * Returns the global singleton instance. Do not construct directly.
+     */
+    static get Instance(): ViewTypeEngine;
+    private _viewTypes;
+    /**
+     * Loads the view-type metadata. Cheap to call repeatedly — a no-op once loaded
+     * (unless `forceRefresh`). Callers should `await ViewTypeEngine.Instance.Config(...)`
+     * at entry before reading {@link ViewTypes} or calling {@link GetAvailableViewTypes}.
+     */
+    Config(forceRefresh?: boolean, contextUser?: UserInfo, provider?: IMetadataProvider): Promise<void>;
+    /** All active view-type metadata rows, ordered by Sequence. */
+    get ViewTypes(): MJViewTypeEntity[];
+    /**
+     * Resolve a single descriptor instance from a `DriverClass` name via the ClassFactory.
+     * Returns null when no descriptor is registered under that key (e.g. Cluster / Tag Cloud,
+     * whose renderer plugins are out of scope for this round).
+     */
+    GetDescriptor(driverClass: string): BaseViewTypeDescriptor | null;
+    /**
+     * Returns the descriptors that are available for the given entity, in metadata
+     * Sequence order. For each active `MJ: View Types` row we resolve its `DriverClass`
+     * descriptor from the ClassFactory and keep it only when `IsAvailableFor(entity)` is true.
+     *
+     * Rows whose `DriverClass` has no registered descriptor (e.g. Cluster, Tag Cloud this
+     * round) are silently skipped — so seeding metadata for a not-yet-implemented view type
+     * is harmless.
+     *
+     * @param entity the entity the viewer is displaying
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    GetAvailableViewTypes(entity: EntityInfo, provider?: IMetadataProvider): IViewTypeDescriptor[];
+    /**
+     * Like {@link GetAvailableViewTypes} but returns each available view type's metadata
+     * row paired with its resolved descriptor — so callers that need the `MJ: View Types`
+     * row ID (for `UserView.ViewTypeID` persistence and per-view-type config keying) get
+     * both without a second lookup.
+     *
+     * @param entity the entity the viewer is displaying
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    GetAvailableViewTypeRows(entity: EntityInfo, provider?: IMetadataProvider): Array<{
+        ViewType: MJViewTypeEntity;
+        Descriptor: IViewTypeDescriptor;
+    }>;
+    /**
+     * Awaits each registered descriptor's optional {@link IViewTypeDescriptor.EnsureAvailabilityData}
+     * hook so synchronous {@link GetAvailableViewTypeRows} predicates can read from now-populated
+     * caches (e.g. the Cluster view type preloading which entities have Entity Documents). Each
+     * DriverClass is prepared at most once; a descriptor whose hook throws simply stays unavailable.
+     *
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    EnsureAvailabilityData(provider?: IMetadataProvider): Promise<void>;
+}
+//# sourceMappingURL=view-type.engine.d.ts.map

package/dist/lib/view-types/view-type.engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-type.engine.d.ts","sourceRoot":"","sources":["../../../src/lib/view-types/view-type.engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA4B,UAAU,EAAE,iBAAiB,EAAY,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE/H,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEpF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAe,SAAQ,UAAU,CAAC,cAAc,CAAC;IAC5D;;OAEG;IACH,WAAkB,QAAQ,IAAI,cAAc,CAE3C;IAED,OAAO,CAAC,UAAU,CAA0B;IAE5C;;;;OAIG;IACU,MAAM,CAAC,YAAY,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAchH,+DAA+D;IAC/D,IAAW,SAAS,IAAI,gBAAgB,EAAE,CAEzC;IAED;;;;OAIG;IACI,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI;IAoBxE;;;;;;;;;;;OAWG;IACI,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,EAAE;IAQrG;;;;;;;;OAQG;IACI,wBAAwB,CAC7B,MAAM,EAAE,UAAU,EAClB,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,KAAK,CAAC;QAAE,QAAQ,EAAE,gBAAgB,CAAC;QAAC,UAAU,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAezE;;;;;;;OAOG;IACU,sBAAsB,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CAmBjF"}

package/dist/lib/view-types/view-type.engine.js

@@ -0,0 +1,138 @@
+import { BaseEngine, Metadata } from '@memberjunction/core';
+import { MJGlobal } from '@memberjunction/global';
+import { BaseViewTypeDescriptor } from './view-type.contracts';
+/**
+ * ViewTypeEngine
+ * --------------
+ * Loads the `MJ: View Types` metadata rows (active, ordered by Sequence) and, given an
+ * `EntityInfo`, returns the list of view-type descriptors that are AVAILABLE for that
+ * entity.
+ *
+ * "Available" means two things both hold:
+ *   1. The view type is active and seeded in `MJ: View Types`.
+ *   2. A descriptor is registered with the ClassFactory under the row's `DriverClass`
+ *      AND that descriptor's `IsAvailableFor(entity)` predicate returns true.
+ *
+ * This is intentionally Angular-free — it depends only on `@memberjunction/core`,
+ * `@memberjunction/global`, and `@memberjunction/core-entities` so it can run anywhere.
+ * It extends {@link BaseEngine} for automatic caching + entity-event auto-refresh.
+ */
+export class ViewTypeEngine extends BaseEngine {
+    /**
+     * Returns the global singleton instance. Do not construct directly.
+     */
+    static get Instance() {
+        return super.getInstance();
+    }
+    _viewTypes = [];
+    /**
+     * Loads the view-type metadata. Cheap to call repeatedly — a no-op once loaded
+     * (unless `forceRefresh`). Callers should `await ViewTypeEngine.Instance.Config(...)`
+     * at entry before reading {@link ViewTypes} or calling {@link GetAvailableViewTypes}.
+     */
+    async Config(forceRefresh, contextUser, provider) {
+        const c = [
+            {
+                Type: 'entity',
+                EntityName: 'MJ: View Types',
+                PropertyName: '_viewTypes',
+                Filter: 'IsActive = 1',
+                OrderBy: 'Sequence ASC',
+                CacheLocal: true
+            }
+        ];
+        await this.Load(c, provider ?? Metadata.Provider, forceRefresh, contextUser);
+    }
+    /** All active view-type metadata rows, ordered by Sequence. */
+    get ViewTypes() {
+        return this._viewTypes;
+    }
+    /**
+     * Resolve a single descriptor instance from a `DriverClass` name via the ClassFactory.
+     * Returns null when no descriptor is registered under that key (e.g. Cluster / Tag Cloud,
+     * whose renderer plugins are out of scope for this round).
+     */
+    GetDescriptor(driverClass) {
+        if (!driverClass) {
+            return null;
+        }
+        const descriptor = MJGlobal.Instance.ClassFactory.CreateInstance(BaseViewTypeDescriptor, driverClass);
+        // When no concrete descriptor is registered for this DriverClass, the ClassFactory falls
+        // back to instantiating the abstract BaseViewTypeDescriptor itself — which yields a useless
+        // instance with undefined Name/DisplayName/Icon/RendererComponent (and IsAvailableFor()===true
+        // by default). That would render as a blank, clickable item in the switcher. Treat that
+        // fallback as "not registered" so unimplemented view types (e.g. a seeded TagCloud row with
+        // no TagCloudViewType class) are simply omitted.
+        if (!descriptor || !descriptor.RendererComponent || descriptor.Name !== driverClass) {
+            return null;
+        }
+        return descriptor;
+    }
+    /**
+     * Returns the descriptors that are available for the given entity, in metadata
+     * Sequence order. For each active `MJ: View Types` row we resolve its `DriverClass`
+     * descriptor from the ClassFactory and keep it only when `IsAvailableFor(entity)` is true.
+     *
+     * Rows whose `DriverClass` has no registered descriptor (e.g. Cluster, Tag Cloud this
+     * round) are silently skipped — so seeding metadata for a not-yet-implemented view type
+     * is harmless.
+     *
+     * @param entity the entity the viewer is displaying
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    GetAvailableViewTypes(entity, provider) {
+        if (!entity) {
+            return [];
+        }
+        return this.GetAvailableViewTypeRows(entity, provider).map(r => r.Descriptor);
+    }
+    /**
+     * Like {@link GetAvailableViewTypes} but returns each available view type's metadata
+     * row paired with its resolved descriptor — so callers that need the `MJ: View Types`
+     * row ID (for `UserView.ViewTypeID` persistence and per-view-type config keying) get
+     * both without a second lookup.
+     *
+     * @param entity the entity the viewer is displaying
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    GetAvailableViewTypeRows(entity, provider) {
+        if (!entity) {
+            return [];
+        }
+        const result = [];
+        for (const row of this._viewTypes) {
+            const descriptor = this.GetDescriptor(row.DriverClass);
+            if (descriptor && descriptor.IsAvailableFor(entity, provider)) {
+                result.push({ ViewType: row, Descriptor: descriptor });
+            }
+        }
+        return result;
+    }
+    /**
+     * Awaits each registered descriptor's optional {@link IViewTypeDescriptor.EnsureAvailabilityData}
+     * hook so synchronous {@link GetAvailableViewTypeRows} predicates can read from now-populated
+     * caches (e.g. the Cluster view type preloading which entities have Entity Documents). Each
+     * DriverClass is prepared at most once; a descriptor whose hook throws simply stays unavailable.
+     *
+     * @param provider optional metadata provider (multi-provider scenarios)
+     */
+    async EnsureAvailabilityData(provider) {
+        const prepared = new Set();
+        await Promise.all(this._viewTypes.map(async (row) => {
+            if (prepared.has(row.DriverClass)) {
+                return;
+            }
+            prepared.add(row.DriverClass);
+            const descriptor = this.GetDescriptor(row.DriverClass);
+            if (descriptor) {
+                try {
+                    await descriptor.EnsureAvailabilityData(provider);
+                }
+                catch {
+                    // Availability data failed to load — the descriptor's predicate stays false.
+                }
+            }
+        }));
+    }
+}
+//# sourceMappingURL=view-type.engine.js.map

package/dist/lib/view-types/view-type.engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-type.engine.js","sourceRoot":"","sources":["../../../src/lib/view-types/view-type.engine.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseEngine, BaseEnginePropertyConfig, EntityInfo, IMetadataProvider, Metadata, UserInfo } from '@memberjunction/core';\nimport { MJGlobal } from '@memberjunction/global';\nimport { MJViewTypeEntity } from '@memberjunction/core-entities';\nimport { BaseViewTypeDescriptor, IViewTypeDescriptor } from './view-type.contracts';\n\n/**\n * ViewTypeEngine\n * --------------\n * Loads the `MJ: View Types` metadata rows (active, ordered by Sequence) and, given an\n * `EntityInfo`, returns the list of view-type descriptors that are AVAILABLE for that\n * entity.\n *\n * \"Available\" means two things both hold:\n *   1. The view type is active and seeded in `MJ: View Types`.\n *   2. A descriptor is registered with the ClassFactory under the row's `DriverClass`\n *      AND that descriptor's `IsAvailableFor(entity)` predicate returns true.\n *\n * This is intentionally Angular-free — it depends only on `@memberjunction/core`,\n * `@memberjunction/global`, and `@memberjunction/core-entities` so it can run anywhere.\n * It extends {@link BaseEngine} for automatic caching + entity-event auto-refresh.\n */\nexport class ViewTypeEngine extends BaseEngine<ViewTypeEngine> {\n  /**\n   * Returns the global singleton instance. Do not construct directly.\n   */\n  public static get Instance(): ViewTypeEngine {\n    return super.getInstance<ViewTypeEngine>();\n  }\n\n  private _viewTypes: MJViewTypeEntity[] = [];\n\n  /**\n   * Loads the view-type metadata. Cheap to call repeatedly — a no-op once loaded\n   * (unless `forceRefresh`). Callers should `await ViewTypeEngine.Instance.Config(...)`\n   * at entry before reading {@link ViewTypes} or calling {@link GetAvailableViewTypes}.\n   */\n  public async Config(forceRefresh?: boolean, contextUser?: UserInfo, provider?: IMetadataProvider): Promise<void> {\n    const c: Partial<BaseEnginePropertyConfig>[] = [\n      {\n        Type: 'entity',\n        EntityName: 'MJ: View Types',\n        PropertyName: '_viewTypes',\n        Filter: 'IsActive = 1',\n        OrderBy: 'Sequence ASC',\n        CacheLocal: true\n      }\n    ];\n    await this.Load(c, provider ?? Metadata.Provider, forceRefresh, contextUser);\n  }\n\n  /** All active view-type metadata rows, ordered by Sequence. */\n  public get ViewTypes(): MJViewTypeEntity[] {\n    return this._viewTypes;\n  }\n\n  /**\n   * Resolve a single descriptor instance from a `DriverClass` name via the ClassFactory.\n   * Returns null when no descriptor is registered under that key (e.g. Cluster / Tag Cloud,\n   * whose renderer plugins are out of scope for this round).\n   */\n  public GetDescriptor(driverClass: string): BaseViewTypeDescriptor | null {\n    if (!driverClass) {\n      return null;\n    }\n    const descriptor = MJGlobal.Instance.ClassFactory.CreateInstance<BaseViewTypeDescriptor>(\n      BaseViewTypeDescriptor,\n      driverClass\n    );\n    // When no concrete descriptor is registered for this DriverClass, the ClassFactory falls\n    // back to instantiating the abstract BaseViewTypeDescriptor itself — which yields a useless\n    // instance with undefined Name/DisplayName/Icon/RendererComponent (and IsAvailableFor()===true\n    // by default). That would render as a blank, clickable item in the switcher. Treat that\n    // fallback as \"not registered\" so unimplemented view types (e.g. a seeded TagCloud row with\n    // no TagCloudViewType class) are simply omitted.\n    if (!descriptor || !descriptor.RendererComponent || descriptor.Name !== driverClass) {\n      return null;\n    }\n    return descriptor;\n  }\n\n  /**\n   * Returns the descriptors that are available for the given entity, in metadata\n   * Sequence order. For each active `MJ: View Types` row we resolve its `DriverClass`\n   * descriptor from the ClassFactory and keep it only when `IsAvailableFor(entity)` is true.\n   *\n   * Rows whose `DriverClass` has no registered descriptor (e.g. Cluster, Tag Cloud this\n   * round) are silently skipped — so seeding metadata for a not-yet-implemented view type\n   * is harmless.\n   *\n   * @param entity the entity the viewer is displaying\n   * @param provider optional metadata provider (multi-provider scenarios)\n   */\n  public GetAvailableViewTypes(entity: EntityInfo, provider?: IMetadataProvider): IViewTypeDescriptor[] {\n    if (!entity) {\n      return [];\n    }\n\n    return this.GetAvailableViewTypeRows(entity, provider).map(r => r.Descriptor);\n  }\n\n  /**\n   * Like {@link GetAvailableViewTypes} but returns each available view type's metadata\n   * row paired with its resolved descriptor — so callers that need the `MJ: View Types`\n   * row ID (for `UserView.ViewTypeID` persistence and per-view-type config keying) get\n   * both without a second lookup.\n   *\n   * @param entity the entity the viewer is displaying\n   * @param provider optional metadata provider (multi-provider scenarios)\n   */\n  public GetAvailableViewTypeRows(\n    entity: EntityInfo,\n    provider?: IMetadataProvider\n  ): Array<{ ViewType: MJViewTypeEntity; Descriptor: IViewTypeDescriptor }> {\n    if (!entity) {\n      return [];\n    }\n\n    const result: Array<{ ViewType: MJViewTypeEntity; Descriptor: IViewTypeDescriptor }> = [];\n    for (const row of this._viewTypes) {\n      const descriptor = this.GetDescriptor(row.DriverClass);\n      if (descriptor && descriptor.IsAvailableFor(entity, provider)) {\n        result.push({ ViewType: row, Descriptor: descriptor });\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Awaits each registered descriptor's optional {@link IViewTypeDescriptor.EnsureAvailabilityData}\n   * hook so synchronous {@link GetAvailableViewTypeRows} predicates can read from now-populated\n   * caches (e.g. the Cluster view type preloading which entities have Entity Documents). Each\n   * DriverClass is prepared at most once; a descriptor whose hook throws simply stays unavailable.\n   *\n   * @param provider optional metadata provider (multi-provider scenarios)\n   */\n  public async EnsureAvailabilityData(provider?: IMetadataProvider): Promise<void> {\n    const prepared = new Set<string>();\n    await Promise.all(\n      this._viewTypes.map(async row => {\n        if (prepared.has(row.DriverClass)) {\n          return;\n        }\n        prepared.add(row.DriverClass);\n        const descriptor = this.GetDescriptor(row.DriverClass);\n        if (descriptor) {\n          try {\n            await descriptor.EnsureAvailabilityData(provider);\n          } catch {\n            // Availability data failed to load — the descriptor's predicate stays false.\n          }\n        }\n      })\n    );\n  }\n}\n"]}