@omnia/fx 8.0.0-dev → 8.0.1-dev

package/internal-do-not-import-from-here/core/console/ConsoleKeyboardShortcuts.d.ts

@@ -1,6 +1 @@
-export declare class ConsoleKeyboardShortcuts {
-    static init(): void;
-    private static initOmniaConsole;
-    private static initCommandPalette;
-    private static initDocs;
-}
+export {};

package/internal-do-not-import-from-here/runtime/core/InternalManifestLog.d.ts

@@ -4,11 +4,13 @@
  * So we will implement lazy log internal here and that write log manifest info with query string debug=true&manifest=true
 */
 export declare class InternalManifestLog {
-    private static _enableLog;
+    private static _enableErrorLog;
+    private static _enableDebugLog;
     /**
     * Logs the object with logLevel.debug
     */
     static logDebug(callback: () => any): void;
+    static logError(callback: () => any): void;
     /**
     * Logs the time since the start measurement point was created
     * (Only if window.href contains ?debug=true)

package/internal-do-not-import-from-here/runtime/core/ManifestResourceLoader.d.ts

@@ -42,6 +42,7 @@ export declare class ManifestResourceLoader {
     static ready: () => Future<void>;
     static getManifest: (omniaServiceId: GuidValue, manifestId: GuidValue) => LoadableBundleManifest;
     static getManifestById: (manifestId: GuidValue) => LoadableBundleManifest;
+    static validateSecurityResource(manifestToLoad: LoadableBundleManifest): boolean;
     static loadResources: (manifestToLoad: LoadableBundleManifest) => Future<ManifestLoadResult>;
     static manifestSubscriber: () => IManifestSubscriber;
     private static LoadLoadableElement;

package/internal-do-not-import-from-here/shared/http/Http.d.ts

@@ -0,0 +1,143 @@
+import { HttpConfig, HttpCredentials, HttpMethods, HttpResponse, Future, Guid } from "../models";
+export declare class HttpBuilder {
+    _config?: HttpConfig;
+    constructor(_config?: HttpConfig);
+    /**
+     * The base url for the client e.g. https://api.com
+     *
+     * @param {string} baseUrl
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withBaseUrl(baseUrl: string): HttpBuilder;
+    /**
+     * If headers should be included in the request
+     *
+     * @param {{ [name: string]: string }} headers
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withHeaders(headers: {
+        [name: string]: string;
+    }): HttpBuilder;
+    /**
+     * If credential options should be included in the request, Default is "include" for this method
+     *
+     * @param {HttpCredentials} [credentials]
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withCredentials(credentials?: HttpCredentials): HttpBuilder;
+    /**
+     * Sets up the client defaults to call a json api
+     *
+     * @return {*}
+     * @memberof HttpBuilder
+     */
+    withJsonApiSupport(): HttpBuilder;
+    withExecuteOnWorker(): this;
+    /**
+     * Sets up the client defaults to call a json api
+     *
+     * @return {*}
+     * @memberof HttpBuilder
+     */
+    getConfig(): HttpConfig;
+    /**
+     * Creates the Http instance with the configuration options
+     *
+     * @return {*}  {Http}
+     * @memberof HttpBuilder
+     */
+    build(): Http;
+}
+export declare class Http {
+    _baseConfig: HttpConfig | Future<HttpConfig> | Promise<HttpConfig>;
+    /**
+     * Create a new instance of Http using the HttpBuilder
+     * @static
+     * @param {(HttpConfig | Future<HttpConfig> | Promise<HttpConfig>)} [config]
+     * @return {*}  {Http}
+     * @memberof Http
+     */
+    static new(config?: HttpConfig): HttpBuilder;
+    /**
+     * Creates a new instance of Http with default configurations for calling Omnia Service Apis
+     *
+     * @static
+     * @return {*}
+     * @memberof Http
+     */
+    static default(config?: HttpConfig): Http;
+    constructor(config?: HttpConfig | Future<HttpConfig> | Promise<HttpConfig>);
+    /**
+     *Performs a GET request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    get<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a DELETE request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    delete<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    head<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    post<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    put<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    patch<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    private createRequest;
+    buildRequestInit(method: HttpMethods, url: string, config: HttpConfig, reqConfig: HttpConfig, body: any): {
+        requestUrl: string;
+        reqInit: RequestInit;
+    };
+}
+export declare function http(omniaServiceId: Guid, executeOnWorker?: boolean): Http;
+export declare function http(options: HttpConfig): Http;

package/internal-do-not-import-from-here/shared/http/index.d.ts

@@ -1 +1 @@
-export * from "./Bring";
+export * from "./Http";

package/internal-do-not-import-from-here/shared/models/HttpCommon.d.ts

@@ -0,0 +1,24 @@
+export type HttpMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export type HttpCacheOptions = "no-cache" | "reload" | "force-cache" | "only-if-cached";
+export type HttpCredentials = "include" | "omit" | "same-origin";
+export interface HttpInterceptOptions {
+    beforeRequest?: (request: HttpConfig) => HttpConfig;
+    afterRequest?: <T>(response: HttpResponse<T>, request: HttpConfig) => HttpResponse<T>;
+}
+export interface HttpConfig {
+    baseUrl?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    cache?: HttpCacheOptions;
+    interceptors?: HttpInterceptOptions;
+    abortable?: boolean;
+    credentials?: HttpCredentials;
+    executeOnWorker?: boolean;
+}
+export interface HttpResponse<TData> {
+    data?: TData;
+    status: Number;
+    statusText: String;
+    ok: Boolean;
+}

package/internal-do-not-import-from-here/shared/models/WorkerProxyFuncs.d.ts

@@ -1,4 +1,4 @@
-import { BringResponse } from "./Bring";
+import { HttpResponse } from "./HttpCommon";
 import { Guid } from "./Guid";
 import { WorkerProxyFunction } from "./Workers";
 export declare const WorkerProxyFuncs: {
@@ -9,6 +9,6 @@ export declare const WorkerProxyFuncs: {
         httpRequest: WorkerProxyFunction<{
             url: string;
             reqInit: Omit<RequestInit, "window" | "signal">;
-        }, Promise<BringResponse<any>>>;
+        }, Promise<HttpResponse<any>>>;
     };
 };

package/internal-do-not-import-from-here/shared/models/hub/activities/Activity.d.ts

@@ -1,4 +1,4 @@
-import { DynamicState, GuidValue, StronglyTypedId } from "../..";
+import { ActivityRenderer, ActivityRendererReference, DynamicState, GuidValue, StronglyTypedId } from "../..";
 import { ChannelId } from "./ActivityChannel";
 import { ActivitySenderId } from "./ActivitySender";
 export type ActivityId = StronglyTypedId<number, "ActivityId">;
@@ -8,9 +8,10 @@ export declare function ActivityTypeId(id: GuidValue): ActivityTypeId;
 export interface Activity<TRenderState = DynamicState> extends ActivityBase {
     id: ActivityId;
     state: TRenderState;
+    renderer: ActivityRenderer | ActivityRendererReference;
     senderId: ActivitySenderId;
 }
-export interface ActivityResponse extends ActivityBase {
+export interface ActivityWithJson extends ActivityBase {
     id: ActivityId;
     senderId: ActivitySenderId;
     stateJson: string;
@@ -24,6 +25,10 @@ export interface ActivityBase {
     expires?: Date;
     createdAt: Date;
 }
+export interface ActivityRenderState<TActivityState = DynamicState, TIdentityState = DynamicState> {
+    activity: TActivityState;
+    identity: TIdentityState;
+}
 export interface HubIdentityProperty {
     name: string;
     values: Array<string>;

package/internal-do-not-import-from-here/shared/models/hub/activities/ActivityRenderer.d.ts

@@ -1,3 +1,4 @@
+import { VelcronAppDefinition } from "@omnia/fx-models";
 import { GuidValue, StronglyTypedId } from "../..";
 export type ActivityRendererId = StronglyTypedId<string, "ActivityRendererId">;
 export declare function ActivityRendererId(id: GuidValue): ActivityRendererId;
@@ -5,6 +6,9 @@ export interface ActivityRendererReference {
     id: ActivityRendererId;
     version: string;
 }
-export interface ActivityRenderer extends ActivityRendererReference {
+export interface ActivityRendererWithJson extends ActivityRendererReference {
     definition: string;
 }
+export interface ActivityRenderer extends ActivityRendererReference {
+    definition: VelcronAppDefinition;
+}

package/internal-do-not-import-from-here/shared/models/hub/activities/FeedResult.d.ts

@@ -1,6 +1,6 @@
-import { Activity, ActivityId } from "./Activity";
-import { ActivityRenderer, ActivityRendererId } from "./ActivityRenderer";
-import { IdentityActivity } from "./IdentityActivity";
+import { Activity, ActivityId, ActivityWithJson } from "./Activity";
+import { ActivityRenderer, ActivityRendererId, ActivityRendererWithJson } from "./ActivityRenderer";
+import { IdentityActivity, IdentityActivityWithJson } from "./IdentityActivity";
 export interface FeedResult {
     renderers: {
         [key: ActivityRendererId]: ActivityRenderer;
@@ -9,3 +9,11 @@ export interface FeedResult {
     activities: Array<Activity>;
     nextStartingFromId: ActivityId;
 }
+export interface FeedResultWithJson {
+    renderers: {
+        [key: ActivityRendererId]: ActivityRendererWithJson;
+    };
+    identityActivities: Array<IdentityActivityWithJson>;
+    activities: Array<ActivityWithJson>;
+    nextStartingFromId: ActivityId;
+}

package/internal-do-not-import-from-here/shared/models/index.d.ts

@@ -5,7 +5,7 @@ export * from "./Topic";
 export * from "./Workers";
 export * from "./SharedConstants";
 export * from "./WorkerProxyFuncs";
-export * from "./Bring";
+export * from "./HttpCommon";
 export * from "./Future";
 export * from "./Tokens";
 export * from "./Tenant";

package/internal-do-not-import-from-here/shared/models/index.js

@@ -9,7 +9,7 @@ tslib_1.__exportStar(require("./Topic"), exports);
 tslib_1.__exportStar(require("./Workers"), exports);
 tslib_1.__exportStar(require("./SharedConstants"), exports);
 tslib_1.__exportStar(require("./WorkerProxyFuncs"), exports);
-tslib_1.__exportStar(require("./Bring"), exports);
+tslib_1.__exportStar(require("./HttpCommon"), exports);
 tslib_1.__exportStar(require("./Future"), exports);
 tslib_1.__exportStar(require("./Tokens"), exports);
 tslib_1.__exportStar(require("./Tenant"), exports);

package/internal-do-not-import-from-here/shared/services/DefineService.d.ts

@@ -1,6 +1,6 @@
-import { useBring } from "../http";
+import { http } from "../http";
 export declare function defineService<TActions extends {
     [key: string]: Function;
 }>(setup: (ctx: {
-    useBring: typeof useBring;
+    http: typeof http;
 }) => TActions): () => TActions;

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/AppInstanceRollup.d.ts

@@ -9,6 +9,7 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
+            readonly settings?: AppInstanceRollupBlockSettings;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -50,7 +51,6 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly settings?: AppInstanceRollupBlockSettings;
             readonly blockInstance?: IBlockInstance<AppInstanceRollupBlockSettings>;
             readonly hideBlock?: (hidden: boolean) => void;
             readonly onFollowAppInstanceClicked?: (appInstanceInfoUser: AppInstanceInfoUser) => void;

package/internal-do-not-import-from-here/ux/app/appinstance/settings/components/MetricTab.d.ts

@@ -7,6 +7,7 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
+            readonly settings?: AppInstanceRollupBlockSettings;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -48,7 +49,6 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly settings?: AppInstanceRollupBlockSettings;
             readonly updateSettings?: (settings: AppInstanceRollupBlockSettings) => void;
             readonly isInWcm?: boolean;
         };

package/internal-do-not-import-from-here/ux/docs/Docs.d.ts

@@ -55,6 +55,7 @@ export declare const frameworkDocumentationCategories: {
     services: DocumentationCategory;
     components: DocumentationCategory;
     store: DocumentationCategory;
+    use: DocumentationCategory;
     theming: DocumentationCategory;
 };
 export interface ComponentSpecRegistration {

package/internal-do-not-import-from-here/ux/docs/omfx/components/docs/Properties.d.ts

@@ -0,0 +1,91 @@
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/docs/omfx/components/docs/Slots.d.ts

@@ -0,0 +1 @@
+export {};