@sassoftware/vi-api 0.0.29 → 1.5.0

package/component/component-api.service.js

@@ -0,0 +1,161 @@
+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, get, isFunction, noop, set } from "lodash-es";
+import { compileAngularJsComponent, getAngularJsInjectable } from "../../commons/angular-angularjs-utils";
+import { TimeSliderComponent } from "../../commons/time-slider/time-slider.component";
+import { SandSearchInputComponent } from "../../sand/search-input/sand-search-input.component";
+import { ControlCollectionComponent } from "../../spb/page-viewer/control-collection/control-collection.component";
+import { zoneWrap } from "../../commons/api-utils";
+import { SearchAndSelectWithPreviewComponent } from "../../sand/search-and-select-with-preview/search-and-select-with-preview.component";
+/* The details of our supported components. This maps each SviComponent to its associated selector
+   or Angular Component class. This indirection allows us to change implementation details at a later
+   date. */
+export const components = {
+    "svi-control-collection": {
+        selector: "spb-control-collection",
+        class: ControlCollectionComponent
+    },
+    "svi-relationship-details": {
+        selector: "relate-to-details",
+        fnBindings: {
+            onLinkReasonSelected: { params: ["linkReason"] },
+            setApi: { params: ["api"] },
+            onRelatedPageLoad: { params: [] },
+            onRelatedPageChange: { params: ["change"] },
+            onRelationshipValuesChange: { params: ["current", "previous"] }
+        },
+        defaultBindings: {
+            onRelatedPageLoad: () => {
+                window.sas.vi?.component.detectChanges();
+            }
+        }
+    },
+    "svi-search-input": {
+        selector: "sand-search-input",
+        class: SandSearchInputComponent
+    },
+    "svi-page": {
+        selector: "spb-sds-page-viewer",
+        fnBindings: {
+            setApi: { params: ["api"] },
+            onDirty: { params: ["isDirty"] },
+            onPageLoad: { params: [] },
+            onChange: { params: ["change"] }
+        },
+        defaultBindings: {
+            onPageLoad: () => {
+                window.sas.vi?.component.detectChanges();
+            }
+        }
+    },
+    "svi-search-and-select-with-preview": {
+        selector: "sand-search-and-select-with-preview",
+        class: SearchAndSelectWithPreviewComponent
+    },
+    "svi-time-slider": {
+        selector: "svi-time-slider",
+        class: TimeSliderComponent
+    }
+};
+let ComponentApiService = class ComponentApiService {
+    constructor(componentFactoryResolver, injector, appRef, ngZone) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.injector = injector;
+        this.appRef = appRef;
+        this.ngZone = ngZone;
+        this.$timeout = () => getAngularJsInjectable("$timeout");
+        this.getApi = () => {
+            return {
+                create: zoneWrap(this.create.bind(this), this.ngZone),
+                detectChanges: this.detectChanges
+            };
+        };
+        this.detectChanges = (callback = noop) => {
+            // $timeout for AngularJS
+            this.$timeout()(() => {
+                // ngZone.run() for Angular. A single $timeout is not enough in some circumstances.
+                this.ngZone.run(callback);
+            });
+        };
+        this.compileComponent = (component, target, bindings = {}) => {
+            const details = components[component];
+            bindings = { ...bindings, ...details.defaultBindings };
+            if (details.class) {
+                return this.compileAngularComponent(details.class, target, bindings);
+            }
+            return this.compileAngularJSComponent(component, target, bindings);
+        };
+        this.compileAngularJSComponent = (component, target, bindings = {}) => {
+            const selector = components[component].selector;
+            const attrs = this.getAngularJsAttrs(bindings, component);
+            const { element, destroy, scope } = compileAngularJsComponent(target, selector, bindings, attrs, true);
+            return Promise.resolve({ element, destroy, component: scope });
+        };
+        this.getAngularJsAttrs = (bindings, component) => {
+            const attrs = {};
+            each(bindings, (_v, k) => {
+                const fnBinding = get(components[component].fnBindings, k);
+                if (fnBinding) {
+                    // The attribute value for function bindings (&) must be of the form:
+                    //     on-foo="onFoo(arg1,arg2)"
+                    // If not, the function will not be invoked. The argument names must
+                    // also match those that the caller uses.
+                    const params = fnBinding.params.join(",");
+                    set(attrs, k, `${k}(${params})`);
+                }
+                else {
+                    set(attrs, k, k);
+                }
+            });
+            return attrs;
+        };
+    }
+    create(component, target, bindings) {
+        if (!(component in components)) {
+            console.warn(`"${component}" is not a component that can be created.`);
+            return Promise.reject();
+        }
+        return this.compileComponent(component, target, bindings).then((result) => {
+            this.detectChanges();
+            return result;
+        });
+    }
+    compileAngularComponent(component, target, bindings) {
+        const factory = this.componentFactoryResolver.resolveComponentFactory(component);
+        const ref = factory.create(this.injector);
+        const instance = ref.instance;
+        const element = ref.hostView.rootNodes[0];
+        const subscriptions = [];
+        each(bindings, (v, k) => {
+            if (isFunction(v)) {
+                const sub = instance[k].subscribe(v);
+                subscriptions.push(sub);
+            }
+            else {
+                set(instance, k, v);
+            }
+        });
+        this.appRef.attachView(ref.hostView);
+        target.append(element);
+        this.appRef.tick();
+        return Promise.resolve({
+            element,
+            destroy: () => {
+                this.appRef.detachView(ref.hostView);
+                ref.destroy();
+                each(subscriptions, s => s.unsubscribe());
+                this.detectChanges();
+            },
+            component: instance
+        });
+    }
+};
+ComponentApiService = __decorate([
+    Injectable()
+], ComponentApiService);
+export { ComponentApiService };

package/config/config-api.d.ts

@@ -87,6 +87,7 @@ export interface ConfigApi {
      * @method
      * @description Registers a solution extension with the application.
      * @param config {SolutionExtension} Solution extension configuration.
+     * @returns A Promise that resolves once the solution has been sent to the cache.
      */
-    registerSolutionExtension(config: SolutionExtension): void;
+    registerSolutionExtension(config: SolutionExtension): Promise<void>;
 }

package/config/config-api.service.js

@@ -0,0 +1,54 @@
+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";
+let ConfigApiService = class ConfigApiService {
+    constructor(networkConfigService, controlService) {
+        this.networkConfigService = networkConfigService;
+        this.controlService = controlService;
+        this.getSoftExpansionLimit = () => {
+            return this.networkConfigService.getSoftExpansionLimit().toPromise();
+        };
+        this.getHardExpansionLimit = () => {
+            return this.networkConfigService.getHardExpansionLimit().toPromise();
+        };
+        this.getSolutions = () => {
+            return this.solutions;
+        };
+        this.registerSolution = (key, label, version) => {
+            if (key && label && !this.solutions.has(key)) {
+                this.solutions.set(key, { label, version });
+            }
+        };
+        this.getSolutionExtension = (name) => {
+            return this.controlService
+                .whenInitialized()
+                .pipe(map(() => this.controlService.getControlByName(name)))
+                .toPromise();
+        };
+        this.registerSolutionExtension = (config) => {
+            return this.controlService.registerControl(config).toPromise();
+        };
+        this.solutions = new Map();
+    }
+    getApi() {
+        return {
+            getSoftExpansionLimit: this.getSoftExpansionLimit,
+            getHardExpansionLimit: this.getHardExpansionLimit,
+            getSolutions: this.getSolutions,
+            registerSolution: this.registerSolution,
+            getSolutionExtension: this.getSolutionExtension,
+            registerSolutionExtension: this.registerSolutionExtension
+        };
+    }
+};
+ConfigApiService = __decorate([
+    Injectable({
+        providedIn: "root"
+    })
+], ConfigApiService);
+export { ConfigApiService };

package/control/control-api.d.ts

@@ -2,7 +2,7 @@ import { FileChange, SASObjectAttachedFile, SASUploadedFile } from "../file/file
 import { PageMode, PageModel } from "../page-model/page-model-api";
 import { FieldType, FieldTypeToValue } from "./data-types";
 import { PageDataChange, PageModeChange, StateChange } from "./events";
-import { Control, RefreshablePageControlOptions, SlidingPanelProperties, TypeAttributes } from "./page";
+import { Control, RefreshablePageControlOptions, SlidingPanelContent, SlidingPanelProperties, TypeAttributes } from "./page";
 import { FieldTypeToRestrictions, FileRestrictions } from "./restrictions";
 import { AttachmentFormData } from "./file";
 /**
@@ -126,6 +126,11 @@ export interface ControlApi<ControlTypeAttributes extends TypeAttributes = TypeA
      * @returns The aria label that should be applied.
      */
     getAriaLabel: () => string;
+    /**
+     * Sets the value of the component specific API
+     * @param componentSpecificApi
+     */
+    setComponentSpecificApi(componentSpecificApi?: any): void;
 }
 /**
  * Methods and properties related to the state of the control.
@@ -275,9 +280,9 @@ export interface ControlPageApi extends ControlPageApiBase {
      * @method
      * @param handler {function} Function to be invoked on property change.
      * Parameters are (category: string, property: string, currentValue: any, previousValue: any).
-     * Returns void.
+     * @returns A function that stops the handler from being invoked.
      */
-    onPropertyChange(handler: (category: string, property: string, currentValue: any, previousValue: any) => void): void;
+    onPropertyChange(handler: (category: string, property: string, currentValue: any, previousValue: any) => void): () => void;
     /**
      * Returns the disabled status of the page toolbar.
      * @method
@@ -312,25 +317,32 @@ export interface ControlPageApi extends ControlPageApiBase {
      * By default, attempts to refresh all controls.
      * Specify categoryToRefresh or controlToRefresh to restrict what is refreshed.
      * @method
-     * @param categoryToRefresh {(string|undefined)} Name of the category to be refreshed.
+     * @param [categoryToRefresh] {(string|undefined)} Name of the category to be refreshed.
      * @param [controlToRefresh] {Control} Individual control to be refreshed.
      */
-    reloadRefreshableControls(categoryToRefresh: string | undefined, controlToRefresh: Control): void;
+    reloadRefreshableControls(categoryToRefresh?: string, controlToRefresh?: Control): void;
     /**
      * Sets a page to be dirty, that is, when it has been edited and not saved.
      * @method
      */
     setPageDirty(): void;
+    /**
+     * Gets the dirty state of the page.
+     * @method
+     */
+    getPageDirty(): boolean | undefined;
     /**
      * Toggle the page-level sliding panel. This panel should be used to contain information that is
      * supplementary to the document, for example attachments or workflow tasks.
      * @method
-     * @param sectionLabel {string} Describes the section, this should be internationalised.
-     * @param contentUrl {string} Contains the template URL of the contents to be ng-included.
-     * @param [panelProperties] {SlidingPanelProperties} Properties that are exposed to the template from the caller.
+     * @param [sectionLabel] {string} Describes the section, this should be internationalised.
+     * @param [content] {SlidingPanelContent} The content of the sliding panel.
+     * @param [panelProperties] {SlidingPanelProperties} Properties for the panel.
+     *      When providing a url for content: the panel properties will be available on the controller's "slidingPanel" object.
+     *      When providing a selector for content: the properties will be set on the element to be created.
      * @param [onClose] {function} A callback function invoked when the panel is dismissed. There are no parameters. Returns void.
      */
-    toggleSlidingPanel(sectionLabel: string, contentUrl: string, panelProperties?: SlidingPanelProperties, onClose?: () => void): void;
+    toggleSlidingPanel<T>(sectionLabel?: string, content?: SlidingPanelContent<T>, panelProperties?: SlidingPanelProperties, onClose?: () => void): void;
     /**
      * Checks if a page is in edit mode.
      * @method

package/control/data-types.d.ts

@@ -6,4 +6,9 @@ export interface UserGroup {
     type: "user" | "group";
 }
 export declare type FieldTypeToValue<Type extends FieldType> = Type extends "BOOLEAN" ? boolean : Type extends "STRING" | DateDataType | "REFERENCEDATA" ? string : Type extends NumberDataType ? number : Type extends "JSON" ? object : Type extends "USER_GROUP" ? UserGroup[] : never;
-export declare type FieldValue = undefined | string | number | boolean | object | UserGroup;
+export declare type FieldValue = undefined | string | number | boolean | object | UserGroup | Date | ChildObject[] | null;
+export declare type ChildObject = {
+    id?: string;
+    isNew?: boolean;
+    fieldValues: Record<string, FieldValue>;
+};

package/control/page.d.ts

@@ -1,3 +1,4 @@
+import { Type } from "@angular/core";
 export declare const enum PageModeEvent {
     CREATE = "create",
     EDIT = "edit",
@@ -49,6 +50,19 @@ export interface GlobalControlStates {
 export interface SlidingPanelProperties {
     [property: string]: any;
 }
+/**
+ * Represents the content of a sliding panel.
+ */
+export interface SlidingPanelContent<T> {
+    /**
+     * The name of a custom element to be created in the content pane.
+     */
+    customElementName?: string;
+    /**
+     * An Angular component to be included in the content pane.
+     */
+    instanceClass?: Type<T>;
+}
 export interface RefreshablePageControlOptions {
     refreshCategory?: string;
     requiresIndex?: boolean;

package/control/toolbar-property-api.d.ts

@@ -10,7 +10,8 @@ export interface ToolbarPropertyApi {
          * Registers a function to be invoked whenever one of the calling toolbar control's properties change.
          * @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;
+        onPropertyChange(handler: (category: string, property: string, currentValue: any, previousValue: any) => void): () => void;
     };
 }

package/current-user/currentUser-api.service.js

@@ -0,0 +1,49 @@
+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 { pick } from "lodash-es";
+let CurrentUserApiService = class CurrentUserApiService {
+    constructor(configurationService, featureService, identitiesService) {
+        this.configurationService = configurationService;
+        this.featureService = featureService;
+        this.identitiesService = identitiesService;
+        this.getSessionDetails = () => {
+            return pick(this.configurationService.getSessionDetails(), [
+                "authorizedFeatures",
+                "displayName",
+                "id",
+                "softwareVersionNumber"
+            ]);
+        };
+        this.getUserDetails = () => {
+            return this.identitiesService.getUserDetails(this.userId).toPromise();
+        };
+        this.getUserMemberships = () => {
+            return this.identitiesService.getUserMemberships(this.userId).toPromise();
+        };
+        this.hasAdminFeatures = () => {
+            return this.featureService.hasAdminFeatures();
+        };
+        this.hasFeatures = (features) => {
+            return this.featureService.hasRequiredFeatures(features);
+        };
+        this.userId = configurationService.getSessionDetails().id;
+    }
+    getApi() {
+        return {
+            getSessionDetails: this.getSessionDetails,
+            getUserDetails: this.getUserDetails,
+            getUserMemberships: this.getUserMemberships,
+            hasAdminFeatures: this.hasAdminFeatures,
+            hasFeatures: this.hasFeatures
+        };
+    }
+};
+CurrentUserApiService = __decorate([
+    Injectable()
+], CurrentUserApiService);
+export { CurrentUserApiService };

package/event/event-api.d.ts

@@ -8,6 +8,7 @@ export declare enum PageEvents {
     ModeChangeEvent = "spb::page-mode-change",
     ModelChangeEvent = "spb::page-model-change",
     PanelOpenEvent = "spb::sliding-panel-open",
+    RefreshAttachmentsGrid = "spb::refreshAttachmentsGrid",
     RefreshPageEvent = "spb::refreshPage",
     SelectAttachmentEvent = "spb::Highlighting:SelectAttachment",
     SelectChildObjectEvent = "spb::Highlighting:SelectChildObject",

package/event/event-api.js

@@ -9,6 +9,7 @@ export var PageEvents;
     PageEvents["ModeChangeEvent"] = "spb::page-mode-change";
     PageEvents["ModelChangeEvent"] = "spb::page-model-change";
     PageEvents["PanelOpenEvent"] = "spb::sliding-panel-open";
+    PageEvents["RefreshAttachmentsGrid"] = "spb::refreshAttachmentsGrid";
     PageEvents["RefreshPageEvent"] = "spb::refreshPage";
     PageEvents["SelectAttachmentEvent"] = "spb::Highlighting:SelectAttachment";
     PageEvents["SelectChildObjectEvent"] = "spb::Highlighting:SelectChildObject";

package/event/event-api.service.js

@@ -0,0 +1,32 @@
+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 EventApiService = class EventApiService {
+    constructor(eventService) {
+        this.eventService = eventService;
+        this.publish = (eventName, payload) => {
+            this.eventService.publish(eventName, payload);
+        };
+        this.subscribe = (eventName, observer) => {
+            return this.eventService.subscribe(eventName, observer);
+        };
+        this.unsubscribe = (subscription) => {
+            this.eventService.unsubscribe(subscription);
+        };
+    }
+    getApi() {
+        return {
+            publish: this.publish,
+            subscribe: this.subscribe,
+            unsubscribe: this.unsubscribe
+        };
+    }
+};
+EventApiService = __decorate([
+    Injectable()
+], EventApiService);
+export { EventApiService };

package/file/file-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 FileApiService = class FileApiService {
+    constructor(sviFilesService) {
+        this.sviFilesService = sviFilesService;
+        this.uploadToViFolder = (file, fileName) => {
+            return this.sviFilesService.uploadFileToViFolderFromFile(file, fileName).toPromise();
+        };
+    }
+    getApi() {
+        return {
+            uploadToViFolder: this.uploadToViFolder
+        };
+    }
+};
+FileApiService = __decorate([
+    Injectable()
+], FileApiService);
+export { FileApiService };

package/http/http-api.service.js

@@ -0,0 +1,64 @@
+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 HttpApiService = class HttpApiService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.getApi = () => {
+            return {
+                get: this.get.bind(this),
+                head: this.head.bind(this),
+                post: this.post.bind(this),
+                put: this.put.bind(this),
+                patch: this.patch.bind(this),
+                delete: this.delete.bind(this),
+                options: this.options.bind(this),
+                request: this.request.bind(this)
+            };
+        };
+    }
+    get(url, options) {
+        return this.httpClient.get(url, options);
+    }
+    /**
+     * @typedef {Object} HttpApiService~HeadOptions
+     * @property [headers] {Record<string, string | string[]>}
+     * @property [params] {Record<string, string | string[]>}
+     */
+    /**
+     * Constructs a `HEAD` request that returns a null body and the full HttpResponse.
+     *
+     * @param url {string} Endpoint URL.
+     * @param options {HttpApiService~HeadOptions} HTTP options to send with the request.
+     * @return {Promise<HttpResponse<null>>} A Promise of the HttpResponse for the request with the response body of null.
+     */
+    head(url, options) {
+        return this.httpClient.head(url, options);
+    }
+    post(url, body, options) {
+        return this.httpClient.post(url, body, options);
+    }
+    put(url, body, options) {
+        return this.httpClient.put(url, body, options);
+    }
+    patch(url, body, options) {
+        return this.httpClient.patch(url, body, options);
+    }
+    delete(url, options) {
+        return this.httpClient.delete(url, options);
+    }
+    options(url, options) {
+        return this.httpClient.options(url, options);
+    }
+    request(method, url, options) {
+        return this.httpClient.request(method, url, options);
+    }
+};
+HttpApiService = __decorate([
+    Injectable()
+], HttpApiService);
+export { HttpApiService };

package/localization/localization-api.service.js

@@ -0,0 +1,38 @@
+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 LocalizationApiService = class LocalizationApiService {
+    constructor(formatterService, configurationService) {
+        this.formatterService = formatterService;
+        this.configurationService = configurationService;
+        this.getLocalizedDateTimeFormat = (showTime = true) => {
+            if (showTime) {
+                return this.formatterService.momentShortDateTimeFormatString();
+            }
+            else {
+                return this.formatterService.momentShortDateFormatString();
+            }
+        };
+        this.getLocale = () => {
+            return this.configurationService.getUserLocale();
+        };
+        this.getDirection = () => {
+            return this.configurationService.getUserDirection();
+        };
+    }
+    getApi() {
+        return {
+            getLocalizedDateTimeFormat: this.getLocalizedDateTimeFormat,
+            getLocale: this.getLocale,
+            getDirection: this.getDirection
+        };
+    }
+};
+LocalizationApiService = __decorate([
+    Injectable()
+], LocalizationApiService);
+export { LocalizationApiService };

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

@@ -0,0 +1,30 @@
+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";
+import { MetadataApiService } from "../metadata-api.service";
+let AdminMetadataApiService = class AdminMetadataApiService extends MetadataApiService {
+    constructor(linksMetadataService, picklistService, sandMetadataService, spbEntityMetadataService, resourceService) {
+        super(linksMetadataService, picklistService, sandMetadataService, spbEntityMetadataService);
+        this.resourceService = resourceService;
+        this.getFieldDataTypeLabels = () => {
+            const fdhResources = this.resourceService.getResources().fdh;
+            const documentSvc = getAngularJsInjectable("documentSvc");
+            return documentSvc.getFieldDataTypeLabels(fdhResources);
+        };
+    }
+    getApi() {
+        return {
+            ...super.getApi(),
+            getFieldDataTypeLabels: this.getFieldDataTypeLabels
+        };
+    }
+};
+AdminMetadataApiService = __decorate([
+    Injectable()
+], AdminMetadataApiService);
+export { AdminMetadataApiService };

package/metadata/metadata-api.d.ts

@@ -24,6 +24,7 @@ export interface SandDataObject extends DataObject {
     attachmentsIndexedForSearch?: boolean;
     resolvedEntity?: boolean;
     indexedForSearch?: boolean;
+    requireSearchBeforeCreate?: boolean;
 }
 export interface DataObject extends PersistableObject {
     name: string;
@@ -208,6 +209,8 @@ export interface MetadataApi {
      */
     getIconForEntity(objectType: string, iconType?: string): string | undefined;
     /**
+     * @deprecated Use `getRootTypes()` and `getResolvedEntities()` instead.
+     *
      * @method
      * @description Gets metadata for both entities and resolved entities
      * @returns A promise resolving to Search entity metadata.