@sassoftware/vi-api 0.0.29 → 1.5.0

package/metadata/metadata-api.service.js

@@ -0,0 +1,85 @@
+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 MetadataApiService = class MetadataApiService {
+    constructor(linksMetadataService, picklistService, sandMetadataService, spbEntityMetadataService) {
+        this.linksMetadataService = linksMetadataService;
+        this.picklistService = picklistService;
+        this.sandMetadataService = sandMetadataService;
+        this.spbEntityMetadataService = spbEntityMetadataService;
+        this.dataDictionaryService = () => getAngularJsInjectable("dataDictionaryService");
+        this.getEntityAccessRules = (objectType) => {
+            return {
+                create: this.dataDictionaryService().canCreateDataSourceType(objectType),
+                read: this.dataDictionaryService().canReadDataSourceType(objectType),
+                update: this.dataDictionaryService().canUpdateDataSourceType(objectType)
+            };
+        };
+        this.getEntity = (objectType) => {
+            return this.dataDictionaryService().getDataSource(objectType);
+        };
+        this.getField = (objectType, fieldName) => {
+            return this.dataDictionaryService().getFieldMetadata(objectType, fieldName);
+        };
+        this.getManagedEntityTypes = () => {
+            return this.dataDictionaryService().getManagedDocumentTypes();
+        };
+        this.getRootTypes = () => {
+            return this.dataDictionaryService().getRootTypes();
+        };
+        this.getChildEntityTypes = (objectType) => {
+            return this.dataDictionaryService().getSubDocumentTypes({ name: objectType });
+        };
+        this.getAllValidRelationshipTypes = (objectType, relationshipObjectType, relationshipName) => {
+            const relateToMenuService = getAngularJsInjectable("relateToMenuService");
+            return relateToMenuService.getAllValidLinkTypes(objectType, relationshipObjectType, relationshipName);
+        };
+        this.getResolvedEntities = () => {
+            return this.dataDictionaryService().getEntities();
+        };
+        this.getResolvedEntityMetadata = (objectType) => {
+            return this.dataDictionaryService().getEntityMetadata(objectType);
+        };
+        this.getIconForEntity = (objectType, iconType) => {
+            return this.spbEntityMetadataService.getIconForEntity(objectType, iconType);
+        };
+        /**
+         * @deprecated Use `getRootTypes()` and `getResolvedEntities()` instead.
+         */
+        this.getSearchMetadata = () => {
+            return this.sandMetadataService.getMetadata().toPromise();
+        };
+        this.getReferenceData = (refDataName, options) => {
+            return this.picklistService.getPicklist(refDataName, options).toPromise();
+        };
+        this.getRelationshipsFilteredByEndType = (endType, includeHeterogeneous = false) => {
+            return this.linksMetadataService.getLinksFilteredByEndType(endType, includeHeterogeneous).toPromise();
+        };
+    }
+    getApi() {
+        return {
+            getEntityAccessRules: this.getEntityAccessRules,
+            getEntity: promiseWrap(this.getEntity),
+            getField: promiseWrap(this.getField),
+            getManagedEntityTypes: promiseWrap(this.getManagedEntityTypes),
+            getRootTypes: promiseWrap(this.getRootTypes),
+            getChildEntityTypes: promiseWrap(this.getChildEntityTypes),
+            getAllValidRelationshipTypes: promiseWrap(this.getAllValidRelationshipTypes),
+            getIconForEntity: this.getIconForEntity,
+            getResolvedEntities: promiseWrap(this.getResolvedEntities),
+            getResolvedEntityMetadata: promiseWrap(this.getResolvedEntityMetadata),
+            getSearchMetadata: this.getSearchMetadata,
+            getReferenceData: this.getReferenceData,
+            getRelationshipsFilteredByEndType: this.getRelationshipsFilteredByEndType
+        };
+    }
+};
+MetadataApiService = __decorate([
+    Injectable()
+], MetadataApiService);
+export { MetadataApiService };

package/object/object-api.d.ts

@@ -1,4 +1,4 @@
-import { Relationship, StoredObjectFieldDTO } from "../svi-datahub";
+import { Relationship, StoredObjectFieldDTO, Comment } from "../svi-datahub";
 import { FileOperation } from "../file/file-api";
 import { PageModel } from "../page-model/page-model-api";
 import { ClientSheet, Sheet } from "../sheet/sheet-api";
@@ -77,13 +77,13 @@ export interface ObjectApi {
      * @description Updates an existing object with the provided data.
      * @param objectType {string} Object type.
      * @param objectId {string} Object ID.
-     * @param objectTypeId {string} Object type ID.
+     * @param objectTypeId {number} Object type ID.
      * @param objectTypeVersion {number} Object type version.
      * @param fieldValues {FieldValues} Field values of the object.
      * @param [options] {UpdateObjectOptions} Optional extra parameters.
      * @return A promise that resolves to the updated object once the object has successfully been updated.
      */
-    updateObject(objectType: string, objectId: string, objectTypeId: string, objectTypeVersion: number, fieldValues: FieldValues, options?: UpdateObjectOptions): Promise<VIObject>;
+    updateObject(objectType: string, objectId: string, objectTypeId: number, objectTypeVersion: number, fieldValues: FieldValues, options?: UpdateObjectOptions): Promise<VIObject>;
     /**
      * @method
      * @description Deletes an object.
@@ -96,12 +96,12 @@ export interface ObjectApi {
      * @method
      * @description Creates an object.
      * @param objectType {string} Object type.
-     * @param objectTypeId {string} Object type ID.
+     * @param objectTypeId {number} Object type ID.
      * @param fieldValues {FieldValues} Field values of the object.
      * @param [options] {CreateObjectOptions} Optional extra parameters.
      * @return A promise that resolves to the created object once the object has successfully been created.
      */
-    createObject(objectType: string, objectTypeId: string, fieldValues: FieldValues, options?: CreateObjectOptions): Promise<VIObject>;
+    createObject(objectType: string, objectTypeId: number, fieldValues: FieldValues, options?: CreateObjectOptions): Promise<VIObject>;
     /**
      * @method
      * @description Gets relationship via the relationship ID.
@@ -219,10 +219,11 @@ export interface VIObject {
     createdAt: string;
     displayLabel?: string;
     lastUpdatedAt: string;
-    objectTypeId: string;
+    objectTypeId: number;
     objectTypeName: string;
     sheets?: Sheet[];
     id: string;
+    title?: string;
 }
 export interface ValidationResult {
     isValid: boolean;
@@ -441,10 +442,10 @@ export interface ObjectRelationship {
     qualifiedTypeName?: string;
 }
 export interface AttachmentRow {
-    description: string;
+    description?: string;
     location: string;
     id: string;
-    uploadedBy: string;
+    uploadedBy?: string;
     name: string;
     size: number;
     type: string;
@@ -488,18 +489,6 @@ export interface FileAssociationResponse {
     displayOrder?: number;
     links?: RestRepresentationsLink[];
 }
-export interface Comment {
-    category: string;
-    createDate: string;
-    detail: string;
-    id: number;
-    lastUpdatedBy: string;
-    lastUpdatedAt: string;
-    author: {
-        id: string;
-        name: string;
-    };
-}
 export interface DisplayTextFields {
     name: string;
     displayIndex: number;

package/object/object-api.service.js

@@ -0,0 +1,207 @@
+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 { map } from "rxjs/operators";
+import { getAngularJsInjectable } from "../../commons/angular-angularjs-utils";
+let ObjectApiService = class ObjectApiService {
+    constructor(attachmentsService, childObjectViewerValidationService) {
+        this.attachmentsService = attachmentsService;
+        this.childObjectViewerValidationService = childObjectViewerValidationService;
+        this.documentService = () => getAngularJsInjectable("spbDocumentService");
+        this.documentDisplayFormatter = () => getAngularJsInjectable("spbDocumentDisplayFormatter");
+        this.dataDictionaryService = () => getAngularJsInjectable("dataDictionaryService");
+        this.getObjectAccessRules = (objectType, objectId) => {
+            return {
+                canReadObject: this.dataDictionaryService().canReadDocument(objectType, objectId),
+                canUpdateObject: this.dataDictionaryService().canUpdateDocument(objectType, objectId),
+                canDeleteObject: this.dataDictionaryService().canDeleteDocument(objectType, objectId)
+            };
+        };
+        this.getObject = (objectType, objectId, includeDisplayLabel = true) => {
+            return this.documentService().getDocument(objectType, objectId, { includeDisplayLabel });
+        };
+        this.getChildObjects = (objectType, objectId, childObjectType, maxResponses = 25) => {
+            return this.documentService().getSubDocuments(objectId, objectType, childObjectType, { maxResponses });
+        };
+        this.updateObject = (objectType, objectId, objectTypeId, objectTypeVersion, fieldValues, options) => {
+            return this.documentService().saveDocument(objectTypeId, objectType, objectTypeVersion, objectId, fieldValues, options?.fileOperations, options?.sheets, options?.isExternalObject);
+        };
+        this.deleteObject = (objectType, objectId) => {
+            return this.documentService().deleteDocument(objectType, objectId);
+        };
+        this.createObject = (objectType, objectTypeId, fieldValues, options) => {
+            return this.documentService().createDocument(objectTypeId, objectType, fieldValues, options?.fileOperations, options?.comments, options?.sheets);
+        };
+        this.getObjectRelationship = (relationshipId) => {
+            return this.documentService().getLink(relationshipId);
+        };
+        this.updateObjectRelationship = (relationshipId, payload) => {
+            return this.documentService().saveLink(relationshipId, payload);
+        };
+        this.deleteObjectRelationship = (relationshipId) => {
+            return this.documentService().deleteLink(relationshipId);
+        };
+        this.relateObject = (from, to, relationship) => {
+            return new Promise((resolve, reject) => {
+                this.documentService()
+                    .linkDocument(this.convertObjectForType(from), this.convertObjectForType(to), this.convertObjectRelationshipForName(relationship))
+                    .then(result => {
+                    resolve(result.data);
+                })
+                    .catch(error => {
+                    reject(error.data.message);
+                });
+            });
+        };
+        this.getObjectSummaryLabel = (objectType, objectId) => {
+            return this.documentService().getDocumentSummaryLabel(objectType, objectId);
+        };
+        this.createAndRelateObject = (from, to, relationship) => {
+            return new Promise((resolve, reject) => {
+                this.documentService()
+                    .createAndLinkDocument(this.convertObjectForType(from), this.convertObjectForData(to), this.convertObjectRelationshipForName(relationship))
+                    .then(result => {
+                    resolve(result.data);
+                })
+                    .catch(error => {
+                    reject(error.data.message);
+                });
+            });
+        };
+        this.formatObjectFieldsForDisplay = (objects, objectType, options) => {
+            return this.documentDisplayFormatter().processDocumentArray(objects, objectType, options?.skipFormatReferenceData ?? false, options?.skipFormatUserGroups ?? false, options?.skipFormatBooleans ?? false, options?.formatCallback);
+        };
+        this.uploadAttachment = (attachmentModel, objectType, objectId) => {
+            return this.attachmentsService
+                .createAttachment(attachmentModel, objectType, objectId)
+                .pipe(map(result => result.body ?? {}))
+                .toPromise()
+                .catch(error => Promise.reject(error.message));
+        };
+        this.deleteAttachment = (objectType, objectId, attachmentId) => {
+            return this.attachmentsService
+                .removeAttachment(objectType, objectId, attachmentId)
+                .toPromise()
+                .then(() => Promise.resolve())
+                .catch(error => Promise.reject(error.message));
+        };
+        this.getAttachment = (objectType, objectId, attachmentId) => {
+            return this.attachmentsService
+                .getAttachment(objectId, objectType, attachmentId)
+                .pipe(map(result => result.body ?? {}))
+                .toPromise()
+                .catch(error => Promise.reject(error.message));
+        };
+        this.validate = (pageModel, childObject) => {
+            return this.childObjectViewerValidationService
+                .validate(pageModel, childObject)
+                .toPromise();
+        };
+        /**
+         * Edits the property names of the type to conform to AngularJS services currently injected.
+         *
+         * fieldValues to data
+         * objectTypeName to name
+         *
+         * @param object {VIObject} The SAS Visual Investigator Object to be edited.
+         * @return {ObjectForDocumentServiceRelationships}
+         * @ignore
+         *
+         */
+        this.convertObjectForData = (object) => {
+            return {
+                data: object.fieldValues,
+                fileOperations: object.fileOperations,
+                comments: object.comments,
+                createdAt: object.createdAt,
+                lastUpdatedAt: object.lastUpdatedAt,
+                objectTypeId: object.objectTypeId,
+                type: object.objectTypeName,
+                sheets: object.sheets,
+                id: object.id
+            };
+        };
+        /**
+         * Edits the property names of the type to conform to AngularJS services currently injected.
+         *
+         * objectTypeName to name
+         *
+         * @param object {VIObject} The SAS Visual Investigator Object to be edited.
+         * @returns {ObjectForDocumentServiceRelationships}
+         * @ignore
+         */
+        this.convertObjectForType = (object) => {
+            return {
+                fieldValues: object.fieldValues,
+                fileOperations: object.fileOperations,
+                comments: object.comments,
+                createdAt: object.createdAt,
+                lastUpdatedAt: object.lastUpdatedAt,
+                objectTypeId: object.objectTypeId,
+                type: object.objectTypeName,
+                sheets: object.sheets,
+                id: object.id
+            };
+        };
+        /**
+         * Edits the property names of the type to conform to AngularJS services currently injected.
+         *
+         * relationshipTypeName to name
+         *
+         * @param relationship {ObjectRelationship} Object Relationship to be edited.
+         * @returns {RelationshipForDocumentServiceRelationships}
+         * @ignore
+         */
+        this.convertObjectRelationshipForName = (relationship) => {
+            return {
+                name: relationship.relationshipTypeName,
+                relationshipTypeLabel: relationship.relationshipTypeLabel,
+                id: relationship.id,
+                createdAt: relationship.createdAt,
+                lastUpdatedAt: relationship.lastUpdatedAt,
+                validFrom: relationship.validFrom,
+                validTo: relationship.validTo,
+                displayLabel: relationship.displayLabel,
+                fromObjectTypeName: relationship.fromObjectTypeName,
+                fromObjectTypeVersion: relationship.fromObjectTypeVersion,
+                fromObjectId: relationship.fromObjectId,
+                fromObjectDisplayLabel: relationship.fromObjectDisplayLabel,
+                toObjectTypeName: relationship.toObjectTypeName,
+                toObjectTypeVersion: relationship.toObjectTypeVersion,
+                toObjectId: relationship.toObjectId,
+                toObjectDisplayLabel: relationship.toObjectDisplayLabel,
+                fieldValues: relationship.fieldValues,
+                qualifiedTypeName: relationship.qualifiedTypeName
+            };
+        };
+    }
+    getApi() {
+        return {
+            getObjectRelationship: this.getObjectRelationship,
+            updateObjectRelationship: this.updateObjectRelationship,
+            deleteObjectRelationship: this.deleteObjectRelationship,
+            getObject: this.getObject,
+            updateObject: this.updateObject,
+            deleteObject: this.deleteObject,
+            createObject: this.createObject,
+            getChildObjects: this.getChildObjects,
+            relateObject: this.relateObject,
+            getObjectSummaryLabel: this.getObjectSummaryLabel,
+            createAndRelateObject: this.createAndRelateObject,
+            formatObjectFieldsForDisplay: this.formatObjectFieldsForDisplay,
+            uploadAttachment: this.uploadAttachment,
+            deleteAttachment: this.deleteAttachment,
+            getAttachment: this.getAttachment,
+            getObjectAccessRules: this.getObjectAccessRules,
+            validate: this.validate
+        };
+    }
+};
+ObjectApiService = __decorate([
+    Injectable()
+], ObjectApiService);
+export { ObjectApiService };

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "@sassoftware/vi-api",
-  "version": "0.0.29",
+  "version": "1.5.0",
+  "description": "Types used in the SAS Visual Investigator API",
+  "keywords": [
+    "SAS",
+    "VI",
+    "Visual Investigator",
+    "solution",
+    "extension",
+    "angular",
+    "API",
+    "types"
+  ],
+  "homepage": "https://github.com/sassoftware/vi-solution-extensions",
+  "bugs": {
+    "url": "https://github.com/sassoftware/vi-solution-extensions/issues"
+  },
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sassoftware/vi-solution-extensions"
+  },
   "files": [
     "**/*.d.ts",
-    "**/*.js"
+    "**/*.js",
+    "./README.md",
+    "./LICENSE.txt"
   ],
   "main": "public-api.js",
   "types": "public-api.d.ts",

package/page-admin/page-admin-api.service.js

@@ -0,0 +1,25 @@
+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 PageAdminApiService = class PageAdminApiService {
+    constructor() {
+        this.spbPageDesignerConfigService = () => getAngularJsInjectable("spbPageDesignerConfigService");
+        this.registerPageType = (name, applicationType, templateType, controlGroups, canvasCssClass, previewCssClass, options, dataTypeControlMappings) => {
+            this.spbPageDesignerConfigService().registerPageType(name, applicationType, templateType, controlGroups, canvasCssClass, previewCssClass, options, dataTypeControlMappings);
+        };
+    }
+    getApi() {
+        return {
+            registerPageType: this.registerPageType
+        };
+    }
+};
+PageAdminApiService = __decorate([
+    Injectable()
+], PageAdminApiService);
+export { PageAdminApiService };

package/page-model/page-model-api.d.ts

@@ -1,6 +1,8 @@
+import { FileRestrictions } from "../control/restrictions";
 import { Control } from "../control/page";
 import { FileOperation, SASObjectAttachedFile } from "../file/file-api";
 import { ObjectFieldRestrictions } from "../object/object-api";
+import { PathsRepresentation } from "../svi-sand";
 export declare enum PageMode {
     Create = "create",
     Edit = "edit",
@@ -22,14 +24,17 @@ export interface PageAction {
         actionName: string;
         attributes: {
             [property: string]: any;
-            displayName: string;
-            disabled: string;
+            displayName?: string;
+            disabled?: string;
         };
         controlId?: number;
         displayName: string;
+        type: string;
     };
+    childNodes?: PageAction[];
 }
 export interface PageActions {
+    disabled: boolean;
     items?: PageAction[];
 }
 export interface PageModelData {
@@ -40,20 +45,18 @@ export interface PageModelObjectData {
     data: PageModelData;
     displayLabel?: string;
     fieldRestrictions?: ObjectFieldRestrictions;
-    fileRestrictions?: ObjectFieldRestrictions;
+    fileRestrictions?: Record<string, Record<string, FileRestrictions>>;
     id?: string;
-    linkedPages?: any[];
+    linkedPages?: LinkedPage[];
     mode?: PageMode;
-    objectTypeId?: string;
+    objectTypeId?: number;
     objectTypeVersion?: number;
     serverPageMode?: ServerPageMode;
     template?: PageTemplate;
     templateMetadata?: PageTemplateMetadata;
-    toolbar?: {
-        disabled: boolean;
-        items: Control[];
-    };
+    toolbar?: PageActions;
     type?: string;
+    uuid: string;
 }
 export interface PageModel extends PageModelObjectData {
     attachmentCount?: number;
@@ -72,8 +75,8 @@ export interface PageModel extends PageModelObjectData {
     getAllMissingFileCategories(): Promise<string[]>;
     getAllMissingRequiredFields(): string[];
     setParentModel(parentModel: PageModel): void;
-    getParentModel(): PageModel;
-    destroy(): void;
+    getParentModel(): PageModel | undefined;
+    destroy(): Promise<void>;
 }
 export interface PageTemplate {
     errors?: boolean;
@@ -103,6 +106,11 @@ export interface PageTemplateScreen {
     locked?: boolean;
     childNodes?: Control[];
 }
+export interface LinkedPage {
+    templateUuid?: string;
+    traversalUuid?: string;
+    traversal?: PathsRepresentation;
+}
 /**
  * This API is used for creating a PageModel object from source data.
  * Accessed from the window at window.sas.vi.pageModel.
@@ -111,12 +119,12 @@ export interface PageModelApi {
     /**
      * @method
      * @description Creates a new instance of a PageModel when given the object source.
-     * @param objectSource {PageModelObjectData} Object containing data for the page model.
+     * @param object {Partial<PageModel>} Object containing data for the page model.
      * @param [options] {PageModelApi~CreateFromObjectOptions} Contains a boolean "clone" declaring whether to deep clone the object
      * when creating the Page Model.
      * @returns The instance of PageModel
      */
-    createFromObject(objectSource: PageModelObjectData, options?: {
+    createFromObject(object: Partial<PageModel>, options?: {
         clone?: boolean;
     }): PageModel;
 }

package/page-model/page-model-api.service.js

@@ -0,0 +1,25 @@
+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 PageModelApiService = class PageModelApiService {
+    constructor() {
+        this.createFromObject = (objectSource, options) => {
+            this.spbPageModel = getAngularJsInjectable("spbPageModel");
+            return this.spbPageModel.createFromObject(objectSource, options);
+        };
+    }
+    getApi() {
+        return {
+            createFromObject: this.createFromObject
+        };
+    }
+};
+PageModelApiService = __decorate([
+    Injectable()
+], PageModelApiService);
+export { PageModelApiService };

package/page-state/page-state-api.d.ts

@@ -1,3 +1,4 @@
+import { Template, StoredObjectDTO } from "../svi-datahub";
 /**
  * SAS Visual Investigator API's representation of a UI-Router state.
  * Accessed from the window at window.sas.vi.pageState.
@@ -25,6 +26,18 @@ export interface StateObject {
     root(): StateObject;
     toString(): string;
 }
+export interface HomepageDesignerState {
+    isNew: boolean;
+    page: Template;
+    designerType: string;
+}
+export interface ObjectPageDesignerState {
+    isNew: boolean;
+    page: Template;
+    designerType: string;
+    childEntityDataSources: StoredObjectDTO[];
+    primaryDataSource: StoredObjectDTO;
+}
 /**
  * This API provides functionality that pertains to the page state.
  * Accessed from the window at window.sas.vi.pageState.
@@ -56,4 +69,14 @@ export interface PageStateApi {
      * @param id {string | number} ID of the page to be deleted.
      */
     remove(id: string | number): void;
+    /**
+     * Gives the currently active homepages state, or undefined if a homepage
+     * designer tab is not active.
+     */
+    getCurrentHomepageDesigner(): HomepageDesignerState | undefined;
+    /**
+     * Gives the currently active object pages state, or undefined if an object page
+     * designer tab is not active.
+     */
+    getCurrentObjectPageDesigner(): ObjectPageDesignerState | undefined;
 }

package/page-state/page-state-api.service.js

@@ -0,0 +1,70 @@
+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 PageStateApiService = class PageStateApiService {
+    constructor(spbPageStateService) {
+        this.spbPageStateService = spbPageStateService;
+        this.pageDesignerConfig = () => getAngularJsInjectable("spbPageDesignerConfigService");
+        this.tabs = () => getAngularJsInjectable("TabService");
+        this.getCurrentPageState = () => {
+            return this.spbPageStateService.getCurrentState();
+        };
+        this.getPageState = (id) => {
+            return this.spbPageStateService.get(id);
+        };
+        this.addPageState = (id, state) => {
+            this.spbPageStateService.add(id, state);
+        };
+        this.removePageState = (id) => {
+            this.spbPageStateService.remove(id);
+        };
+        this.getCurrentHomepageDesigner = () => {
+            if (!this.isOnHomepageDesigner())
+                return undefined;
+            return this.spbPageStateService.getCurrentState();
+        };
+        this.getCurrentObjectPageDesigner = () => {
+            if (!this.isOnObjectPageDesigner())
+                return undefined;
+            return this.spbPageStateService.getCurrentState();
+        };
+    }
+    getApi() {
+        return {
+            getCurrent: this.getCurrentPageState,
+            get: this.getPageState,
+            add: this.addPageState,
+            remove: this.removePageState,
+            getCurrentHomepageDesigner: this.getCurrentHomepageDesigner,
+            getCurrentObjectPageDesigner: this.getCurrentObjectPageDesigner
+        };
+    }
+    isOnPageDesigner() {
+        return this.tabs().getActiveTab().type === "pageTemplate";
+    }
+    isOnHomepageDesigner() {
+        if (!this.isOnPageDesigner())
+            return false;
+        const state = this.spbPageStateService.getCurrentState();
+        if (!state)
+            return false;
+        return this.pageDesignerConfig().getDesignerConfig(state.designerType).templateType === "homepage";
+    }
+    isOnObjectPageDesigner() {
+        if (!this.isOnPageDesigner())
+            return false;
+        const state = this.spbPageStateService.getCurrentState();
+        if (!state)
+            return false;
+        return this.pageDesignerConfig().getDesignerConfig(state.designerType).templateType === "page";
+    }
+};
+PageStateApiService = __decorate([
+    Injectable()
+], PageStateApiService);
+export { PageStateApiService };