@sassoftware/vi-api/page-model/page-model-api.d.ts

Types used in the SAS Visual Investigator API

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";
import { TemplateFileCategoryAssociationDTO } from "../svi-datahub";
export declare enum PageMode {
    Create = "create",
    Edit = "edit",
    View = "view",
    Design = "design"
}
export declare const enum ServerPageMode {
    CREATE = "C",
    EDIT = "E",
    VIEW = "V"
}
export interface Condition {
    type: string;
    parameters: Array<string | number | boolean | Condition>;
}
export interface PageAction {
    attrs: {
        actionId: number;
        actionName: string;
        attributes: {
            [property: string]: any;
            displayName?: string;
            disabled?: boolean;
        };
        controlId?: number;
        displayName: string;
        type: string;
    };
    childNodes?: PageAction[];
}
export interface PageActions {
    disabled: boolean;
    items?: PageAction[];
}
export interface PageModelData {
    [property: string]: any;
}
export interface PageModelObjectData {
    clientApplication: string;
    data: PageModelData;
    displayLabel?: string;
    fieldRestrictions?: ObjectFieldRestrictions;
    fileRestrictions?: Record<string, Record<string, FileRestrictions>>;
    id?: string;
    linkedPages?: LinkedPage[];
    mode?: PageMode;
    objectTypeId?: number;
    objectTypeVersion?: number;
    serverPageMode?: ServerPageMode;
    template?: PageTemplate;
    templateMetadata?: PageTemplateMetadata;
    toolbar?: PageActions;
    type?: string;
    uuid: string;
}
export interface PageModel extends PageModelObjectData {
    attachmentCount?: number;
    disableDragDrop?: boolean;
    fileOperations?: FileOperation[];
    isFormSearch?: boolean;
    isSourceDocument?: boolean;
    parent?: PageModel;
    updateData(data: PageModelData | undefined): void;
    isEditable(): boolean;
    isInCreateMode(): boolean;
    isValid(): Promise<boolean>;
    addFileOperation(operation: string, id: string, data?: SASObjectAttachedFile): void;
    removeFileOperation(operation: string, id: string): void;
    removeAllFileOperations(): void;
    getAllMissingFileCategories(): Promise<string[]>;
    getAllMissingRequiredFields(): string[];
    setParentModel(parentModel: PageModel): void;
    getParentModel(): PageModel | undefined;
    destroy(): Promise<void>;
}
export interface PageTemplate {
    errors?: boolean;
    errorDetails?: Error;
    showTabs: boolean;
    id?: number;
    screens: PageTemplateScreen[];
}
export interface PageTemplateMetadata {
    dataSources: PageTemplateMetadataDataSource[];
    fileCategories?: TemplateFileCategoryAssociationDTO[];
    insightsCreationEnabled: boolean;
    insightsEnabled: boolean;
    linkedTemplates: Array<{
        templateUuid: string;
        traversalUuid: string;
    }>;
    resources: {
        [property: string]: string;
    };
    workspaceCreationEnabled: boolean;
    workspaceEnabled: boolean;
}
export interface PageTemplateMetadataDataSource {
    objectName: string;
    fields: string[];
}
export interface PageTemplateScreen {
    id: string;
    name: string;
    locked?: boolean;
    childNodes?: Control[];
}
export interface LinkedPage {
    templateUuid?: string;
    traversalUuid?: string;
    traversal?: PathsRepresentation;
}
export interface IPageEventHook<T extends IPageEventData, R extends IPageEventHookResponse> {
    exec: (pageData: T) => Promise<R | void>;
    /**
     * Run onFail instead of exec if the preceding event action has failed.
     * If not provided, nothing will be executed for this hook in the event of failure.
     */
    onFail?: (pageData: T) => Promise<R | void>;
    /**
     * Hooks are executed in ascending order.
     */
    order?: number;
}
export type IPrePageEventHook<T extends IPageEventData> = Omit<IPageEventHook<T, IPrePageEventHookResponse>, "onFail">;
export type IPostPageEventHook<T extends IPageEventData> = IPageEventHook<T, IPostPageEventHookResponse>;
export interface IPageEventHookResponse {
    message: string;
    messages?: string[];
}
export interface IPrePageEventHookResponse extends IPageEventHookResponse {
    abort: boolean;
}
export type IPostPageEventHookResponse = IPageEventHookResponse;
/**
 * A callback to unregister a page event hook.
 * @returns true if the hook was removed, false if it was already removed.
 */
export type PageEventHookRemove = () => boolean;
export interface IPageEventData {
    pageModel: PageModel;
}
/**
 * Page model events which can have pre-event or post-event hooks.
 */
export declare enum HookablePageEvents {
    /**
     * A pagemodel is being saved as an object.
     */
    SaveObject = "svi:hookable:pagemodel:saveObject"
}
export interface IPageEvent<T extends IPageEventData> {
    /**
     * @method
     * @description Adds a hook to be executed before a hookable event is triggered.
     * @param {IPrePageEventHook} hook the hook which defines the callback to run pre-event.
     */
    addPreHook(hook: IPrePageEventHook<T>): PageEventHookRemove;
    /**
     * @method
     * @description Adds a hook to be executed after a hookable event is triggered.
     * @param {IPostPageEventHook} hook the hook which defines the callback to run post-event.
     */
    addPostHook(hook: IPostPageEventHook<T>): PageEventHookRemove;
    /**
     * @method
     * @description run pre-hooks, execute the action, run post hooks.
     * @param payload is passed as input for any event hooks.
     * @param action the action to perform.
     */
    trigger<R>(payload: T, action: () => Promise<R>): Promise<R>;
}
/**
 * Methods related to page events.
 */
export interface PageEventsApiBase {
    /**
     * @method
     * @description Get a reference to a hookable page event if it is defined.
     * @param eventName The name of the event.
     * @returns The reference to the hookable page event.
     */
    getPageEvent(eventName: HookablePageEvents.SaveObject): IPageEvent<IPageEventData> | undefined;
    getPageEvent<T extends IPageEventData>(eventName: string): IPageEvent<T> | undefined;
}
/**
 * {@link PageEventsApiBase} extension that provides more functionality.
 * @extends PageEventsApiBase
 */
export interface PageEventsApi extends PageEventsApiBase {
    /**
     * @method
     * @description Add a hookable page event. An error is thrown if the event is already registered.
     * @param eventName The name of the event, this should be unique.
     */
    addPageEvent(eventName: string): void | never;
}
/**
 * This API is used for PageModel utilities.
 * Accessed from the window at `window.sas.vi.pageModel`.
 *
 * @example window.sas.vi.pageModel.createFromObject(partialPageModel);
 * @category API
 */
export interface PageModelApi {
    /**
     * Methods related to page event hooks.
     */
    readonly events: PageEventsApi;
    /**
     * @method
     * @description Creates a new instance of a PageModel when given the object source.
     * @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(object: Partial<PageModel>, options?: {
        clone?: boolean;
    }): PageModel;
}
/**
 * @typedef {object} PageModelApi~CreateFromObjectOptions
 * @property [clone] {boolean} Whether or not to clone the page model data or use the referenced values.
 */