@sassoftware/vi-api 0.0.29 → 1.5.0

package/property/property-api.d.ts

@@ -1,5 +1,6 @@
+import { ResourcedString } from "../svi-datahub";
 import { Control } from "../control/page";
-import { TypeAttributes } from "../object/object-api";
+import { ChildNode, TypeAttributes } from "../object/object-api";
 import { PageTemplateMetadata } from "../page-model/page-model-api";
 export interface ToolbarPropertyControl {
     typeAttributes: TypeAttributes;
@@ -7,8 +8,37 @@ export interface ToolbarPropertyControl {
 export interface PropertyConfig {
     [property: string]: any;
     order?: number;
-    required?: boolean;
     type: string;
+    displayName: ResourcedString;
+    required?: boolean | string;
+    localizable?: boolean | string;
+    allowMultiple?: boolean | string;
+    states?: Record<string, boolean>;
+    defaultValue?: any;
+    disabledExpression?: string;
+    picklistName?: string;
+    ignoreRestrictions?: boolean;
+}
+export interface SelectedNode {
+    id: number;
+    node: ChildNode;
+    parentNode?: ChildNode;
+    parentSubDocument: string;
+    dataSources?: {
+        [property: string]: any;
+    };
+}
+/**
+ * This API is available on property editors.
+ */
+export interface EditorApi {
+    /**
+     * Registers a function to be invoked whenever one of the editor's properties changes.
+     * @method
+     * @param handler The function to be invoked.
+     * @returns A function that stops the handler from being invoked.
+     */
+    onPropertyChange(handler: (category: string, property: string, currentValue: any, previousValue: any) => void): () => void;
 }
 /**
  * This API provides the  utility or miscellaneous functionality in SAS Visual Investigator.
@@ -27,6 +57,36 @@ export interface PropertyApi {
      * @param [metadataFn] {PropertyApi~getPropertyEditorMetadata} Function to provide custom metadata.
      */
     registerCustomEditor(elementName: string, type: string, validatorFn?: (propertyConfig: PropertyConfig, propertyKey: string, control: Control | ToolbarPropertyControl) => boolean, metadataFn?: (propertyConfig: PropertyConfig, propertyKey: string, control: Control | ToolbarPropertyControl) => PageTemplateMetadata): void;
+    /**
+     * @method
+     * @description Determines whether or not the child object data source property editor is valid.
+     * Typically passed as a function reference to registerCustomEditor() instead of being called directly.
+     * @param {PropertyConfig} propertyConfig Configuration details relating to the property type. For example, required, type and so on.
+     * @param {string} propertyKey Key where this property's value is stored.
+     * @param {Control | ToolbarPropertyControl} control The control.
+     * @example
+     * window.sas.vi.property.registerCustomEditor(
+     *     name,
+     *     type,
+     *     window.sas.vi.property.validateChildObjectDataSource,
+     *     window.sas.vi.property.getChildObjectMetadata)
+     */
+    validateChildObjectDataSource(propertyConfig: PropertyConfig, propertyKey: string, control: Control): boolean | undefined;
+    /**
+     * @method
+     * @description Get metadata for the child object data source property editor.
+     * Typically passed as a function reference to registerCustomEditor() instead of being called directly.
+     * @param {PropertyConfig} propertyConfig Configuration details relating to the property type. For example, required, type and so on.
+     * @param {string} propertyKey Key where this property's value is stored.
+     * @param {Control | ToolbarPropertyControl} control The control.
+     * @example
+     * window.sas.vi.property.registerCustomEditor(
+     *     name,
+     *     type,
+     *     window.sas.vi.property.validateChildObjectDataSource,
+     *     window.sas.vi.property.getChildObjectMetadata)
+     */
+    getChildObjectMetadata(propertyConfig: PropertyConfig, propertyKey: string, control: Control): PageTemplateMetadata | undefined;
 }
 /**
  * Determines whether or not the property editor is valid.

package/property/property-api.service.js

@@ -0,0 +1,34 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+import { getAngularJsInjectable } from "../../commons/angular-angularjs-utils";
+let PropertyApiService = class PropertyApiService {
+    constructor() {
+        this.propertyEditorConfigService = () => getAngularJsInjectable("spbPropertyEditorService");
+        this.dataSourceValidatorService = () => getAngularJsInjectable("spbDataSourceValidatorService");
+        this.registerCustomEditor = (selector, type, validatorFn, metadataFn) => {
+            this.propertyEditorConfigService().registerCustomEditor(selector, type, validatorFn, metadataFn);
+        };
+        this.validateChildObjectDataSource = (propertyConfig, propertyKey, control) => {
+            return this.dataSourceValidatorService().validateSubDocumentDataSource(propertyConfig, propertyKey, control);
+        };
+        this.getChildObjectMetadata = (propertyConfig, propertyKey, control) => {
+            return this.dataSourceValidatorService().getSubDocumentMetadata(propertyConfig, propertyKey, control);
+        };
+    }
+    getApi() {
+        return {
+            registerCustomEditor: this.registerCustomEditor,
+            validateChildObjectDataSource: this.validateChildObjectDataSource,
+            getChildObjectMetadata: this.getChildObjectMetadata
+        };
+    }
+};
+PropertyApiService = __decorate([
+    Injectable()
+], PropertyApiService);
+export { PropertyApiService };

package/reference-data/refData.service.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+import { getAngularJsInjectable, promiseWrap } from "../../commons/angular-angularjs-utils";
+let RefDataApiService = class RefDataApiService {
+    constructor() {
+        this.referenceDataAdmin = () => getAngularJsInjectable("fdhReferenceDataAdmin");
+        this.getReferenceLists = () => {
+            return this.referenceDataAdmin().getReferenceLists();
+        };
+        this.getReferenceHierarchies = () => {
+            return this.referenceDataAdmin().getReferenceHierarchies();
+        };
+        this.getReferenceListByName = (name, includeArchived) => {
+            // Negating includeArchived as referenceDataAdmin.getListByName handles this opposite to getHierarchyByName.
+            const promise = this.referenceDataAdmin().getListByName(name, !includeArchived);
+            return promise.catch(error => Promise.reject(error?.data?.message));
+        };
+        this.getReferenceHierarchyByName = (name, includeArchived) => {
+            const promise = this.referenceDataAdmin().getHierarchyByName(name, includeArchived);
+            return promise.catch(error => Promise.reject(error?.data?.message));
+        };
+    }
+    getApi() {
+        return {
+            getReferenceLists: promiseWrap(this.getReferenceLists),
+            getReferenceHierarchies: promiseWrap(this.getReferenceHierarchies),
+            getReferenceList: promiseWrap(this.getReferenceListByName),
+            getReferenceHierarchy: promiseWrap(this.getReferenceHierarchyByName)
+        };
+    }
+};
+RefDataApiService = __decorate([
+    Injectable()
+], RefDataApiService);
+export { RefDataApiService };

package/resource/resource-api.service.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+let ResourceApiService = class ResourceApiService {
+    constructor(resourceService) {
+        this.resourceService = resourceService;
+        this.registerResourceBundle = (bundleName, resources) => {
+            this.resourceService.addResourceBundle(bundleName, resources);
+        };
+    }
+    getApi() {
+        return {
+            registerResourceBundle: this.registerResourceBundle
+        };
+    }
+};
+ResourceApiService = __decorate([
+    Injectable()
+], ResourceApiService);
+export { ResourceApiService };

package/score-reps/index.d.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-// Generated using typescript-generator version 2.15.527 on 2022-01-30 09:29:49.
+// Generated using typescript-generator version 2.15.527 on 2023-01-24 10:52:36.
 
 export interface BaseRep extends TrackedResource {
     links?: Link[];

package/search/client/client-search-api.d.ts

@@ -12,7 +12,7 @@ export declare enum Visualization {
     Map = "map",
     Table = "table",
     Timeline = "timeline",
-    Network = "network"
+    Network = "networkDiagram"
 }
 export declare type MapFilter = MapBoundedPolygonFilter | MapRadiusFilter | MapBoundedBoxFilter | MapShapeFilter;
 export interface SearchQuery {
@@ -39,6 +39,7 @@ export interface NetworkData {
         showTransactionDetails?: boolean;
         showTransactionLinks?: boolean;
     };
+    numNodes: number;
 }
 export interface ResolvedObjectIdentifier extends ObjectIdentifier {
     compoundValues: string[];
@@ -50,6 +51,10 @@ export interface SearchAndCreateDialogModel {
     relateToParentLabel?: string;
     canCreate?: boolean;
     linkReasons?: Relationship[];
+    /**
+     * Values returned on the close of the dialog. May be undefined when dialog is cancelled.
+     */
+    result?: SearchAndCreateResponse;
 }
 export interface SearchObject extends ObjectIdentifier {
     title?: string;
@@ -152,8 +157,7 @@ export interface ClientSearchApi extends SearchApi {
      * @description Launches a wizard allowing users to search first, before creating an object/relationship.
      * Relationship wizard is determined by relateToParentLabel or relateToParentName being defined within the wizardValues parameter.
      * @param wizardValues {SearchAndCreateDialogModel} Object containing entity and relationship data.
-     * @param [onRelationshipSuccess] {function} A callback function that is defined when creating a relationship.
-     * It is invoked when a relationship is saved successfully.
+     * @returns {Promise<SearchAndCreateDialogModel>} A promise resolving
      */
-    openSearchAndCreateDialog(wizardValues: SearchAndCreateDialogModel, onRelationshipSuccess?: () => void): Promise<SearchAndCreateResponse>;
+    openSearchAndCreateDialog(wizardValues: SearchAndCreateDialogModel): Promise<SearchAndCreateDialogModel>;
 }

package/search/client/client-search-api.js

@@ -10,5 +10,5 @@ export var Visualization;
     Visualization["Map"] = "map";
     Visualization["Table"] = "table";
     Visualization["Timeline"] = "timeline";
-    Visualization["Network"] = "network";
+    Visualization["Network"] = "networkDiagram";
 })(Visualization || (Visualization = {}));

package/search/client/client-search-api.service.js

@@ -0,0 +1,111 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+import { each } from "lodash-es";
+import { getAngularJsInjectable } from "../../../commons/angular-angularjs-utils";
+import { SEARCH_SELECTION_ID, VisualizationTypes } from "../../../sand/search/search";
+import { zoneWrap } from "../../../commons/api-utils";
+let ClientSearchApiService = class ClientSearchApiService {
+    constructor(ngZone, searchApiService, sandRestService, sandDoSearchService, sandSearchStorageService, sandMetadataService, sandDocumentInfoService, searchAndCreateWizardService) {
+        this.ngZone = ngZone;
+        this.searchApiService = searchApiService;
+        this.sandRestService = sandRestService;
+        this.sandDoSearchService = sandDoSearchService;
+        this.sandSearchStorageService = sandSearchStorageService;
+        this.sandMetadataService = sandMetadataService;
+        this.sandDocumentInfoService = sandDocumentInfoService;
+        this.searchAndCreateWizardService = searchAndCreateWizardService;
+        this.performSearch = (query) => {
+            return new Promise(resolve => {
+                this.sandRestService.search(query).subscribe(result => {
+                    resolve(result);
+                });
+            });
+        };
+        this.navigateSearch = (queryText, visualizationName, mapFilters, queryMode) => {
+            this.sandDoSearchService.doSearch(queryText, visualizationName, mapFilters, queryMode);
+        };
+        this.getCurrentSearchQuery = () => {
+            return this.sandSearchStorageService.getCurrentSearchQuery();
+        };
+        this.createQueryStringFromModel = (queryModel) => {
+            const sandQueryBuilderQueryService = getAngularJsInjectable("sandQueryBuilderQueryService");
+            return this.sandMetadataService
+                .getMetadata()
+                .toPromise()
+                .then(metadata => {
+                return sandQueryBuilderQueryService.createQueryStringFromModel(queryModel, metadata);
+            });
+        };
+        this.getQueryBuilderModel = (id) => {
+            if (!id) {
+                id = SEARCH_SELECTION_ID;
+            }
+            return this.sandSearchStorageService.getQueryBuilderModel(id);
+        };
+        this.setQueryBuilderModel = (queryModel, id) => {
+            if (!id) {
+                id = SEARCH_SELECTION_ID;
+            }
+            this.sandSearchStorageService.saveQueryBuilderModel(id, queryModel);
+        };
+        this.openAddObjectsToWorkspaceDialog = (visualizationName, objects, currentObject, networkData) => {
+            this.sandDocumentSelectionDialogService = getAngularJsInjectable("sandDocumentSelectionDialogService");
+            this.sandDocumentSelectionDialogService.openAddAllObjectsToWorkspaceDialog(visualizationName, currentObject, objects, networkData);
+        };
+        this.openAddImageToInsightsDialog = (imageData, contentType, height, width) => {
+            this.sandDocumentSelectionDialogService = getAngularJsInjectable("sandDocumentSelectionDialogService");
+            this.sandDocumentSelectionDialogService.openAddImageToInsightDialog(VisualizationTypes.Image, imageData, height ?? undefined, width ?? undefined, contentType);
+        };
+        this.addToNewWorkspace = (objectsToAdd, targetObjectType, targetObjectId, visualization, workspaceName, networkData) => {
+            const worksheetService = getAngularJsInjectable("worksheetService");
+            const sheetService = getAngularJsInjectable("sheetService");
+            each(objectsToAdd, object => {
+                this.sandDocumentInfoService.createUniqueKey(object);
+            });
+            const targetObject = {
+                id: targetObjectId,
+                type: targetObjectType,
+                objectType: targetObjectType,
+                isNewDocument: targetObjectId ? false : true
+            };
+            if (!targetObject.isNewDocument && !sheetService.getOpenDocument(targetObject.id, targetObject.type)) {
+                throw Error(`Cannot add objects to workspace. Object of type ${targetObject.type} and id ${targetObject.id} is not open.`);
+            }
+            else {
+                worksheetService.addToSheet(targetObject, undefined, objectsToAdd, visualization, networkData, workspaceName);
+            }
+        };
+        this.openSearchAndCreateDialog = (wizardValues) => {
+            const values = {
+                ...wizardValues,
+                searchFirst: true,
+                initialCreateData: null
+            };
+            return this.searchAndCreateWizardService.launch(values).closeResult.toPromise();
+        };
+    }
+    getApi() {
+        return {
+            ...this.searchApiService.getApi(),
+            performSearch: this.performSearch,
+            navigateSearch: zoneWrap(this.navigateSearch, this.ngZone),
+            getCurrentSearchQuery: this.getCurrentSearchQuery,
+            createQueryStringFromModel: this.createQueryStringFromModel,
+            getQueryBuilderModel: this.getQueryBuilderModel,
+            setQueryBuilderModel: this.setQueryBuilderModel,
+            openAddObjectsToWorkspaceDialog: zoneWrap(this.openAddObjectsToWorkspaceDialog, this.ngZone),
+            openAddImageToInsightsDialog: zoneWrap(this.openAddImageToInsightsDialog, this.ngZone),
+            addToNewWorkspace: zoneWrap(this.addToNewWorkspace, this.ngZone),
+            openSearchAndCreateDialog: zoneWrap(this.openSearchAndCreateDialog, this.ngZone)
+        };
+    }
+};
+ClientSearchApiService = __decorate([
+    Injectable()
+], ClientSearchApiService);
+export { ClientSearchApiService };

package/search/search-api.d.ts

@@ -1,12 +1,12 @@
 export interface QueryBuilderItem {
     booleanValue?: boolean | string;
     boost?: number;
-    dateTimeValue?: string;
-    dateValue?: string;
+    dateTimeValue?: string | Date;
+    dateValue?: string | Date;
     exclude?: boolean;
     field?: string;
-    fromDateTimeValue?: string;
-    fromDateValue?: string;
+    fromDateTimeValue?: string | Date;
+    fromDateValue?: string | Date;
     fromNumericValue?: number;
     numericValue?: number;
     operator?: string;
@@ -22,8 +22,8 @@ export interface QueryBuilderItem {
     stringValidationError?: boolean;
     synonym?: boolean;
     textValue?: string;
-    toDateTimeValue?: string;
-    toDateValue?: string;
+    toDateTimeValue?: string | Date;
+    toDateValue?: string | Date;
     toNumericValue?: number;
     userGroupValue?: Array<{
         id: string;

package/search/search-api.service.js

@@ -0,0 +1,28 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+import { zoneWrap } from "../../commons/api-utils";
+let SearchApiService = class SearchApiService {
+    constructor(sandQueryBuilderDialogService, ngZone) {
+        this.sandQueryBuilderDialogService = sandQueryBuilderDialogService;
+        this.ngZone = ngZone;
+        this.openQueryBuilderDialog = (dialogTitle, submitButtonText, queryModel, enforceObjectType, restrictObjectTypes) => {
+            return this.sandQueryBuilderDialogService
+                .openQueryBuilderDialog(queryModel, dialogTitle, submitButtonText, enforceObjectType, restrictObjectTypes)
+                .toPromise();
+        };
+    }
+    getApi() {
+        return {
+            openQueryBuilderDialog: zoneWrap(this.openQueryBuilderDialog, this.ngZone)
+        };
+    }
+};
+SearchApiService = __decorate([
+    Injectable()
+], SearchApiService);
+export { SearchApiService };

package/sheet/network-menu-handler.service.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+/**
+ * This service is an intermediary between the client API and the Network.
+ * It keeps a record of network menu handlers registered via the client API.
+ */
+let NetworkMenuHandlerService = class NetworkMenuHandlerService {
+    constructor() {
+        this.networkMenuHandlers = new Map();
+    }
+    /**
+     * Call the registered callback function to modify/extend the context menu
+     * @param menuType The type of menu
+     * @param menu The menu object to be modified
+     * @param workspaceClientId The Client ID of the current workspace
+     */
+    extendNetworkContextMenu(menuType, menu, workspaceClientId) {
+        this.networkMenuHandlers.get(menuType)?.(menu, workspaceClientId);
+    }
+    /**
+     * Register a callback function for the given menu type
+     * @param menuType The type of menu: Node or Network
+     * @param callback The callback function
+     */
+    registerNetworkMenuCallback(menuType, callback) {
+        this.networkMenuHandlers.set(menuType, callback);
+    }
+};
+NetworkMenuHandlerService = __decorate([
+    Injectable({
+        providedIn: "root"
+    })
+], NetworkMenuHandlerService);
+export { NetworkMenuHandlerService };

package/sheet/sheet-api.d.ts

@@ -27,15 +27,35 @@ export interface SheetApi {
      */
     getOpenObjectBySheet(sheet: ClientSheet): VIObject | undefined;
     /**
+     * @deprecated use {@link registerNetworkMenuCallback} instead.
      * @method
-     * @description Creates and returns the list containing all Context Menu Items for a right-click on a network diagram node.
+     * @description Deprecated. This function is deprecated and replaced with registerNetworkMenuCallback. The original
+     * function did not allow users to extend the menu being constructed by a context click.
+     *
+     * Creates and returns the list containing all Context Menu Items for a right-click on a network diagram node.
      * The menu is not rendered on the network diagram.
-     * @param workspace {ClientSheet} Workspace containing the network.
+     * @param workspace {ClientSheet} Workspace containing the network. The workspace should not be manually constructed.
      * @param handleAddToWorkspaceFn {function} A callback to handle adding the selected nodes to a Workspace.
      * @param handleAddToInsightsFn {function} A callback to handle adding the NLD to an Insight.
      * @returns Promise resolving to the list containing all Context Menu Items.
      */
-    createContextMenuForNodes(workspace: ClientSheet, handleAddToWorkspaceFn: () => void, handleAddToInsightsFn: () => void): Promise<ContextMenuItem[]>;
+    createContextMenuForNodes(workspace: ClientSheet, handleAddToWorkspaceFn?: () => void, handleAddToInsightsFn?: () => void): Promise<ContextMenuItem[]>;
+    /**
+     * @method
+     * @description Registers a callback that is invoked whenever the node or network context menu is constructed.
+     * The caller can extend the menu to provide access to extra functionality. It is the caller's responsibility
+     * to ensure that they properly extend the menu. Failing to do so can result in application errors.
+     *
+     * The callback can be unregistered by calling this function without passing in a callback function
+     * or setting it to undefined.
+     *
+     * @param menuType {NetworkMenuType} The type of menu to extend.
+     * @param callback {NetworkMenuCallback} The callback function invoked when the context menu is constructed.
+     * This function is passed the menu object, which can be modified/extended, and the "client Id" of the current workspace.
+     * If callback not passed in or is undefined, the callback is unregistered.
+     * @returns void
+     */
+    registerNetworkMenuCallback(menuType: NetworkMenuType, callback?: NetworkMenuCallback): void;
     /**
      * @method
      * @description Adds objects to a workspace selected in the "Add Objects to Workspace" dialog box.
@@ -182,3 +202,15 @@ export interface ClientSheet extends Sheet {
     clientId: string;
     document: ObjectSheetSettings;
 }
+/**
+ * The set of menu types which can be extended
+ * via the registerNetworkMenuCallback function.
+ */
+export declare enum NetworkMenuType {
+    NetworkContext = "networkContext",
+    NodeContext = "nodeContext"
+}
+/**
+ * The type of function that can be registered as a callback for modifying the Network menus.
+ */
+export declare type NetworkMenuCallback = (menu: ContextMenuItem, workspaceClientId: string) => void;

package/sheet/sheet-api.js

@@ -1 +1,9 @@
-export {};
+/**
+ * The set of menu types which can be extended
+ * via the registerNetworkMenuCallback function.
+ */
+export var NetworkMenuType;
+(function (NetworkMenuType) {
+    NetworkMenuType["NetworkContext"] = "networkContext";
+    NetworkMenuType["NodeContext"] = "nodeContext";
+})(NetworkMenuType || (NetworkMenuType = {}));

package/sheet/sheet-api.service.js

@@ -0,0 +1,140 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from "@angular/core";
+import { each } from "lodash-es";
+import { getAngularJsInjectable } from "../../commons/angular-angularjs-utils";
+import { VisualizationTypes } from "../../sand/search/search";
+import { zoneWrap } from "../../commons/api-utils";
+let SheetApiService = class SheetApiService {
+    constructor(networkMenuHandlerService, ngZone, notificationService, resourceService, sandDocumentInfoService) {
+        this.networkMenuHandlerService = networkMenuHandlerService;
+        this.ngZone = ngZone;
+        this.notificationService = notificationService;
+        this.resourceService = resourceService;
+        this.sandDocumentInfoService = sandDocumentInfoService;
+        this.getOpenObject = (objectId, objectType) => {
+            this.sheetService = getAngularJsInjectable("sheetService");
+            return this.sheetService.getOpenDocument(objectId, objectType) ?? undefined;
+        };
+        this.getOpenObjects = () => {
+            this.sheetService = getAngularJsInjectable("sheetService");
+            return this.sheetService.getOpenDocuments();
+        };
+        this.getOpenObjectBySheet = (sheet) => {
+            const worksheetService = getAngularJsInjectable("worksheetService");
+            return worksheetService.getCurrentDocument(sheet);
+        };
+        this.createContextMenuForNodes = (workspace, handleAddToWorkspaceFn, handleAddToInsightsFn) => {
+            return workspace.networkDiagramComponent.framework.view.constructNodeContextMenu(handleAddToWorkspaceFn, handleAddToInsightsFn).items;
+        };
+        this.registerNetworkMenuCallback = (menuType, callback) => {
+            this.networkMenuHandlerService.registerNetworkMenuCallback(menuType, callback);
+        };
+        this.openAddAllObjectsToWorkspaceDialog = (objects, options) => {
+            this.sandDocumentSelectionDialogService = getAngularJsInjectable("sandDocumentSelectionDialogService");
+            this.sandDocumentSelectionDialogService.openAddAllObjectsToWorkspaceDialog(options?.visualizationName, options?.currentObject, objects, options?.networkData);
+        };
+        this.openAddImageToInsightsDialog = (imageData, contentType = "image/png", height, width) => {
+            this.sandDocumentSelectionDialogService = getAngularJsInjectable("sandDocumentSelectionDialogService");
+            if (imageData instanceof Uint8Array) {
+                this.sandDocumentSelectionDialogService.openAddImageToInsightDialog(VisualizationTypes.Image, imageData, height, width, contentType);
+            }
+            else {
+                const util = getAngularJsInjectable("Util");
+                return this.imgToB64(imageData).then((image) => {
+                    const imageBlob = util.b64toBlob(image);
+                    this.sandDocumentSelectionDialogService.openAddImageToInsightDialog(VisualizationTypes.Image, imageBlob, undefined, undefined, contentType);
+                });
+            }
+        };
+        /**
+         * Creates an HTML canvas for the img element.
+         * Generates a new unscaled image based on the original image source.
+         * If there is an error loading the new image, an error alert is displayed.
+         *
+         * @param element {HTMLElement} Element containing the image.
+         * @returns {Promise<string>} A Promise which resolves to the Base64 string representing the image.
+         * @ignore
+         */
+        this.imgToB64 = (element) => {
+            const canvasElement = document.createElement("canvas");
+            const canvasContext = canvasElement.getContext("2d");
+            return new Promise(resolve => {
+                if (canvasContext) {
+                    const originalImageElement = element.querySelector("img");
+                    const unscaledImage = new Image();
+                    unscaledImage.crossOrigin = "Anonymous";
+                    unscaledImage.onload = () => {
+                        canvasElement.width = unscaledImage.width;
+                        canvasElement.height = unscaledImage.height;
+                        // An intermittent issue in IE11 means we use a timeout to move the drawimage out
+                        // of the current execution
+                        // https://stackoverflow.com/questions/25214395/unexpected-call-to-method-or-property-access-while-
+                        // drawing-svg-image-onto-canvas
+                        setTimeout(() => {
+                            canvasContext.drawImage(unscaledImage, 0, 0, unscaledImage.width, unscaledImage.height);
+                            resolve(canvasElement.toDataURL());
+                            canvasElement.remove();
+                        });
+                    };
+                    unscaledImage.onerror = () => {
+                        this.notificationService.alertError(this.resourceService.get("spb.images.addToWorkspaceError.title"), this.resourceService.get("spb.images.addToWorkspaceError.txt"));
+                        canvasElement.remove();
+                    };
+                    unscaledImage.src = originalImageElement.src;
+                }
+            });
+        };
+        this.addToNewWorkspace = (objectsToAdd, targetObjectType, options) => {
+            const worksheetService = getAngularJsInjectable("worksheetService");
+            const sheetService = getAngularJsInjectable("sheetService");
+            each(objectsToAdd, object => {
+                this.sandDocumentInfoService.createUniqueKey(object);
+            });
+            const targetObject = {
+                id: options?.targetObjectId,
+                type: targetObjectType,
+                objectType: targetObjectType,
+                isNewDocument: !options?.targetObjectId
+            };
+            if (!targetObject.isNewDocument &&
+                targetObject.id &&
+                !sheetService.getOpenDocument(targetObject.id, targetObject.type)) {
+                console.warn(`Cannot add objects to workspace. Object of type ${targetObject.type} and id ${targetObject.id} is not open.`);
+            }
+            else {
+                worksheetService.addToSheet(targetObject, undefined, objectsToAdd, options?.visualization, options?.networkData, options?.workspaceName);
+            }
+        };
+        this.addToExistingWorkspace = (targetObject, workspaceClientId, objectsToAdd, networkData, isUndoRedo) => {
+            const worksheetService = getAngularJsInjectable("worksheetService");
+            each(objectsToAdd, object => {
+                this.sandDocumentInfoService.createUniqueKey(object);
+            });
+            worksheetService.addToExistingWorksheet(targetObject, workspaceClientId, objectsToAdd, true, networkData, isUndoRedo);
+        };
+    }
+    getApi() {
+        return {
+            getOpenObject: this.getOpenObject,
+            getOpenObjects: this.getOpenObjects,
+            getOpenObjectBySheet: this.getOpenObjectBySheet,
+            createContextMenuForNodes: zoneWrap(this.createContextMenuForNodes, this.ngZone),
+            registerNetworkMenuCallback: zoneWrap(this.registerNetworkMenuCallback, this.ngZone),
+            openAddAllObjectsToWorkspaceDialog: zoneWrap(this.openAddAllObjectsToWorkspaceDialog, this.ngZone),
+            openAddImageToInsightsDialog: zoneWrap(this.openAddImageToInsightsDialog, this.ngZone),
+            addToExistingWorkspace: zoneWrap(this.addToExistingWorkspace, this.ngZone),
+            addToNewWorkspace: zoneWrap(this.addToNewWorkspace, this.ngZone)
+        };
+    }
+};
+SheetApiService = __decorate([
+    Injectable({
+        providedIn: "root"
+    })
+], SheetApiService);
+export { SheetApiService };