@xh/hoist 71.0.0-SNAPSHOT.1735311286067 → 71.0.0-SNAPSHOT.1735324763102

package/build/types/cmp/viewmanager/{ViewToBlobApi.d.ts → DataAccess.d.ts}

@@ -16,15 +16,24 @@ export interface ViewUpdateSpec {
     isShared?: boolean;
     isDefaultPinned?: boolean;
 }
+export interface ViewUserState {
+    currentView?: string;
+    userPinned: Record<string, boolean>;
+    autoSave: boolean;
+}
 /**
- * Class for accessing and updating views using {@link JsonBlobService}.
+ * Supporting class for accessing and updating ViewManager and View data.
+ *
  * @internal
  */
-export declare class ViewToBlobApi<T> {
+export declare class DataAccess<T> {
     private readonly model;
     constructor(model: ViewManagerModel<T>);
     /** Fetch metadata for all views accessible by current user. */
-    fetchViewInfosAsync(): Promise<ViewInfo[]>;
+    fetchDataAsync(): Promise<{
+        views: ViewInfo[];
+        state: ViewUserState;
+    }>;
     /** Fetch the latest version of a view. */
     fetchViewAsync(info: ViewInfo): Promise<View<T>>;
     /** Create a new view, owned by the current user.*/
@@ -36,6 +45,6 @@ export declare class ViewToBlobApi<T> {
     /** Update a view's value. */
     updateViewValueAsync(view: View<T>, value: Partial<T>): Promise<View<T>>;
     deleteViewsAsync(views: ViewInfo[]): Promise<void>;
-    private trackChange;
+    updateStateAsync(update: Partial<ViewUserState>): Promise<void>;
     private ensureEditable;
 }

package/build/types/cmp/viewmanager/ViewManagerModel.d.ts

@@ -1,8 +1,8 @@
-import { HoistModel, LoadSpec, PersistOptions, PlainObject, TaskObserver, Thunkable } from '@xh/hoist/core';
+import { HoistModel, LoadSpec, PlainObject, TaskObserver, Thunkable } from '@xh/hoist/core';
 import type { ViewManagerProvider } from '@xh/hoist/core';
 import { ViewInfo } from './ViewInfo';
 import { View } from './View';
-import { ViewCreateSpec, ViewUpdateSpec } from './ViewToBlobApi';
+import { ViewCreateSpec, ViewUpdateSpec } from './DataAccess';
 export interface ViewManagerConfig {
     /**
      * True (default) to allow user to opt in to automatically saving changes to their current view.
@@ -44,8 +44,6 @@ export interface ViewManagerConfig {
      * commonly set this based on user roles - e.g. `XH.getUser().hasRole('MANAGE_GRID_VIEWS')`.
      */
     manageGlobal?: Thunkable<boolean>;
-    /** Used to persist the user's state. */
-    persistWith?: ViewManagerPersistOptions;
     /**
      * Required discriminator for the particular class of views to be loaded and managed by this
      * model. Set to something descriptive and specific enough to be identifiable and allow for
@@ -53,6 +51,12 @@ export interface ViewManagerConfig {
      * `tradeBlotterDashboard`.
      */
     type: string;
+    /**
+     * Optional sub-discriminator for the particular location in your app this instance of the
+     * view manager appears in. A particular currentView and pendingValue will be maintained by
+     * instance, but all other options, and the available library of views will be shared by type.
+     */
+    instance?: string;
     /**
      * Optional user-facing display name for the view type, displayed in the ViewManager menu
      * and associated management dialogs and prompts. Defaulted from `type` if not provided.
@@ -63,12 +67,6 @@ export interface ViewManagerConfig {
      */
     globalDisplayName?: string;
 }
-export interface ViewManagerPersistOptions extends PersistOptions {
-    /** True to persist pinning preferences or provide specific PersistOptions. (Default true) */
-    persistPinning?: boolean | PersistOptions;
-    /** True to include pending value or provide specific PersistOptions. (Default false) */
-    persistPendingValue?: boolean | PersistOptions;
-}
 /**
  *  ViewManagerModel coordinates the loading, saving, and management of user-defined bundles of
  *  {@link Persistable} component/model state.
@@ -100,8 +98,8 @@ export declare class ViewManagerModel<T = PlainObject> extends HoistModel {
      */
     static createAsync(config: ViewManagerConfig): Promise<ViewManagerModel>;
     /** Immutable configuration for this model. */
-    persistWith: ViewManagerPersistOptions;
     readonly type: string;
+    readonly instance: string;
     readonly typeDisplayName: string;
     readonly globalDisplayName: string;
     readonly enableAutoSave: boolean;
@@ -144,7 +142,7 @@ export declare class ViewManagerModel<T = PlainObject> extends HoistModel {
      */
     providers: ViewManagerProvider<any>[];
     /** Data access for persisting views. */
-    private api;
+    private dataAccess;
     /** Last time changes were pushed to linked persistence providers */
     private lastPushed;
     get isValueDirty(): boolean;
@@ -183,16 +181,19 @@ export declare class ViewManagerModel<T = PlainObject> extends HoistModel {
     makeViewGlobalAsync(view: ViewInfo): Promise<View<T>>;
     deleteViewsAsync(toDelete: ViewInfo[]): Promise<void>;
     private initAsync;
+    private pendingValueReaction;
+    private autoSaveReaction;
+    private stateReactions;
     private loadViewAsync;
     private maybeAutoSaveAsync;
     private setAsView;
     private handleException;
     private noteSuccess;
+    private get pendingValueStorageKey();
     /**
      * Stringify and parse to ensure that any value set here is valid, serializable JSON.
      */
     private cleanState;
     private confirmDiscardChangesAsync;
     private maybeConfirmSaveAsync;
-    private initPersist;
 }

package/build/types/cmp/viewmanager/index.d.ts

@@ -1,4 +1,4 @@
 export * from './ViewManagerModel';
 export * from './ViewInfo';
 export * from './View';
-export * from './ViewToBlobApi';
+export * from './DataAccess';

package/build/types/svc/JsonBlobService.d.ts

@@ -50,7 +50,11 @@ export declare class JsonBlobService extends HoistService {
     /** Persist a new JSONBlob back to the server. */
     createAsync({ acl, description, type, meta, name, value }: Partial<JsonBlob>): Promise<JsonBlob>;
     /** Modify mutable properties of an existing JSONBlob, as identified by its unique token. */
-    updateAsync(token: string, { acl, description, meta, name, owner, value }: Partial<JsonBlob>): Promise<JsonBlob>;
+    updateAsync(token: string, update: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Create or update a blob for a user with the existing type and name. */
+    createOrUpdateAsync(type: string, name: string, data: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Find a blob owned by this user with a specific type and name.  If none exists, return null.  */
+    findAsync(type: string, name: string): Promise<JsonBlob>;
     /** Archive (soft-delete) an existing JSONBlob, as identified by its unique token. */
     archiveAsync(token: string): Promise<JsonBlob>;
 }

package/cmp/viewmanager/DataAccess.ts

@@ -0,0 +1,179 @@
+/*
+ * This file belongs to Hoist, an application development toolkit
+ * developed by Extremely Heavy Industries (www.xh.io | info@xh.io)
+ *
+ * Copyright © 2024 Extremely Heavy Industries Inc.
+ */
+
+import {PlainObject, XH} from '@xh/hoist/core';
+import {pluralize, throwIf} from '@xh/hoist/utils/js';
+import {map} from 'lodash';
+import {ViewInfo} from './ViewInfo';
+import {View} from './View';
+import {ViewManagerModel} from './ViewManagerModel';
+
+export interface ViewCreateSpec {
+    name: string;
+    group: string;
+    description: string;
+    isShared: boolean;
+    value?: PlainObject;
+}
+
+export interface ViewUpdateSpec {
+    name: string;
+    group: string;
+    description: string;
+    isShared?: boolean;
+    isDefaultPinned?: boolean;
+}
+
+export interface ViewUserState {
+    currentView?: string;
+    userPinned: Record<string, boolean>;
+    autoSave: boolean;
+}
+
+/**
+ * Supporting class for accessing and updating ViewManager and View data.
+ *
+ * @internal
+ */
+export class DataAccess<T> {
+    private readonly model: ViewManagerModel<T>;
+
+    constructor(model: ViewManagerModel<T>) {
+        this.model = model;
+    }
+
+    //---------------
+    // Load/search.
+    //---------------
+    /** Fetch metadata for all views accessible by current user. */
+    async fetchDataAsync(): Promise<{views: ViewInfo[]; state: ViewUserState}> {
+        const {typeDisplayName, type, instance} = this.model;
+        try {
+            const ret = await XH.fetchJson({
+                url: 'xhView/allData',
+                params: {type, viewInstance: instance}
+            });
+            return {
+                views: ret.views.map(v => new ViewInfo(v, this.model)),
+                state: ret.state
+            };
+        } catch (e) {
+            throw XH.exception({
+                message: `Unable to fetch ${pluralize(typeDisplayName)}`,
+                cause: e
+            });
+        }
+    }
+
+    /** Fetch the latest version of a view. */
+    async fetchViewAsync(info: ViewInfo): Promise<View<T>> {
+        const {model} = this;
+        if (!info) return View.createDefault(model);
+        try {
+            const raw = await XH.fetchJson({url: 'xhView/get', params: {token: info.token}});
+            return View.fromBlob(raw, model);
+        } catch (e) {
+            throw XH.exception({message: `Unable to fetch ${info.typedName}`, cause: e});
+        }
+    }
+
+    /** Create a new view, owned by the current user.*/
+    async createViewAsync(spec: ViewCreateSpec): Promise<View<T>> {
+        const {model} = this;
+        try {
+            const raw = await XH.postJson({
+                url: 'xhView/create',
+                body: {type: model.type, ...spec}
+            });
+            return View.fromBlob(raw, model);
+        } catch (e) {
+            throw XH.exception({message: `Unable to create ${model.typeDisplayName}`, cause: e});
+        }
+    }
+
+    /** Update all aspects of a view's metadata.*/
+    async updateViewInfoAsync(view: ViewInfo, updates: ViewUpdateSpec): Promise<View<T>> {
+        try {
+            this.ensureEditable(view);
+            const raw = await XH.postJson({
+                url: 'xhView/updateViewInfo',
+                params: {token: view.token},
+                body: updates
+            });
+            return View.fromBlob(raw, this.model);
+        } catch (e) {
+            throw XH.exception({message: `Unable to update ${view.typedName}`, cause: e});
+        }
+    }
+
+    /** Promote a view to global visibility/ownership status. */
+    async makeViewGlobalAsync(view: ViewInfo): Promise<View<T>> {
+        try {
+            this.ensureEditable(view);
+            const raw = await XH.fetchJson({url: 'xhView/makeGlobal', params: {token: view.token}});
+            return View.fromBlob(raw, this.model);
+        } catch (e) {
+            throw XH.exception({message: `Unable to update ${view.typedName}`, cause: e});
+        }
+    }
+
+    /** Update a view's value. */
+    async updateViewValueAsync(view: View<T>, value: Partial<T>): Promise<View<T>> {
+        try {
+            this.ensureEditable(view.info);
+            const raw = await XH.postJson({
+                url: 'xhView/updateValue',
+                params: {token: view.token},
+                body: value
+            });
+            return View.fromBlob(raw, this.model);
+        } catch (e) {
+            throw XH.exception({
+                message: `Unable to update value for ${view.typedName}`,
+                cause: e
+            });
+        }
+    }
+
+    async deleteViewsAsync(views: ViewInfo[]) {
+        views.forEach(v => this.ensureEditable(v));
+        try {
+            await XH.postJson({
+                url: 'xhView/delete',
+                params: {tokens: map(views, 'token').join(',')}
+            });
+        } catch (e) {
+            throw XH.exception({
+                message: `Failed to delete ${pluralize(this.model.typeDisplayName)}`,
+                cause: e
+            });
+        }
+    }
+
+    //--------------------------
+    // State related changes
+    //--------------------------
+    async updateStateAsync(update: Partial<ViewUserState>) {
+        const {type, instance} = this.model;
+        await XH.postJson({
+            url: 'xhView/updateState',
+            params: {type, viewInstance: instance},
+            body: update
+        });
+    }
+
+    //------------------
+    // Implementation
+    //------------------
+    private ensureEditable(view: ViewInfo) {
+        const {model} = this;
+        throwIf(
+            !view.isEditable,
+            `Cannot save changes to ${model.typeDisplayName} - missing required permission.`
+        );
+    }
+}