@next-core/runtime 1.0.2

package/dist/types/internal/bindListeners.d.ts

@@ -0,0 +1,11 @@
+import type { BrickEventHandler, BrickEventHandlerCallback, BrickEventsMap, BuiltinBrickEventHandler, CustomBrickEventHandler, ExecuteCustomBrickEventHandler, SetPropsCustomBrickEventHandler, UseProviderEventHandler } from "@next-core/types";
+import type { ElementHolder, RuntimeBrickElement, RuntimeContext } from "./interfaces.js";
+export declare function bindListeners(brick: RuntimeBrickElement, eventsMap: BrickEventsMap | undefined, runtimeContext: RuntimeContext): void;
+export declare function unbindListeners(brick: RuntimeBrickElement): void;
+export declare function isBuiltinHandler(handler: BrickEventHandler): handler is BuiltinBrickEventHandler;
+export declare function isUseProviderHandler(handler: BrickEventHandler): handler is UseProviderEventHandler;
+export declare function isCustomHandler(handler: BrickEventHandler): handler is CustomBrickEventHandler;
+export declare function isExecuteCustomHandler(handler: CustomBrickEventHandler): handler is ExecuteCustomBrickEventHandler;
+export declare function isSetPropsCustomHandler(handler: CustomBrickEventHandler): handler is SetPropsCustomBrickEventHandler;
+export declare function listenerFactory(handlers: BrickEventHandler | BrickEventHandler[], runtimeContext: RuntimeContext, runtimeBrick?: ElementHolder): (event: Event) => void;
+export declare function eventCallbackFactory(callback: BrickEventHandlerCallback, runtimeContext: RuntimeContext, runtimeBrick?: ElementHolder): (type: "success" | "error" | "finally" | "progress") => (result?: unknown) => void;

package/dist/types/internal/checkInstalledApps.d.ts

@@ -0,0 +1,6 @@
+import type { MicroApp, Storyboard } from "@next-core/types";
+type AppForCheck = Pick<MicroApp, "id" | "currentVersion" | "installStatus">;
+export declare function preCheckInstalledApps(storyboard: Storyboard): void;
+export declare function waitForCheckingApps(appIds: string[]): Promise<(AppForCheck | undefined)[]>;
+export declare function hasInstalledApp(appId: string, matchVersion?: string): boolean;
+export {};

package/dist/types/internal/checkPermissions.d.ts

@@ -0,0 +1,17 @@
+import type { BrickConf, RouteConf, Storyboard } from "@next-core/types";
+import type { RuntimeContext } from "./interfaces.js";
+export declare function preCheckPermissions(storyboard: Storyboard): Promise<void> | undefined;
+export declare function preCheckPermissionsForBrickOrRoute(container: BrickConf | RouteConf, runtimeContext: RuntimeContext): Promise<void>;
+export declare function preCheckPermissionsForAny(data: unknown): Promise<void> | undefined;
+export declare function validatePermissions(usedActions: string[]): Promise<void>;
+/**
+ * Check the current logged-in user whether to have all
+ * permissions of actions passed to it.
+ *
+ * @param actions - Required permission actions.
+ */
+export declare function checkPermissions(...actions: string[]): boolean;
+/**
+ * Reset permission pre-checks after logged-out.
+ */
+export declare function resetPermissionPreChecks(): void;

package/dist/types/internal/compute/StoryboardFunctions.d.ts

@@ -0,0 +1 @@
+export declare const storyboardFunctions: Readonly<Record<string, Function>>, registerStoryboardFunctions: (functions: import("@next-core/types").StoryboardFunction[] | undefined, app?: import("../../StoryboardFunctionRegistry.js").PartialMicroApp | undefined) => void, checkPermissionsUsage: (functionNames: string[]) => boolean;

package/dist/types/internal/compute/WidgetFunctions.d.ts

@@ -0,0 +1,3 @@
+import { StoryboardFunction } from "@next-core/types";
+export declare const widgetFunctions: Readonly<Record<string, Readonly<Record<string, Function>>>>;
+export declare function registerWidgetFunctions(widgetId: string, functions: StoryboardFunction[], widgetVersion?: string): void;

package/dist/types/internal/compute/WidgetI18n.d.ts

@@ -0,0 +1,3 @@
+import type { MetaI18n } from "@next-core/types";
+export declare function registerWidgetI18n(widgetId: string, i18nData: MetaI18n): void;
+export declare function widgetI18nFactory(widgetId: string): import("i18next").TFunction<string, import("i18next").KeyPrefix<string>, string>;

package/dist/types/internal/compute/checkIf.d.ts

@@ -0,0 +1,23 @@
+import type { BrickConf } from "@next-core/types";
+import type { RuntimeContext } from "../interfaces.js";
+/**
+ * 包含 `if` 条件判断的对象。
+ */
+export interface IfContainer {
+    /**
+     * 条件判断，可以为表达式字符串。
+     *
+     * @example
+     *
+     * ```yaml
+     * - brick: your.any-brick
+     *   if: '<% FLAGS["your-feature-flag"] %>'
+     * ```
+     */
+    if?: unknown;
+}
+export declare function asyncCheckIf(ifContainer: IfContainer, runtimeContext: RuntimeContext): Promise<boolean>;
+export declare function checkIf(ifContainer: IfContainer, runtimeContext: RuntimeContext): boolean;
+export declare function checkIfOfComputed(ifContainer: IfContainer): boolean;
+export declare function asyncCheckBrickIf(brickConf: BrickConf, runtimeContext: RuntimeContext): Promise<boolean>;
+export declare function checkIfByTransform(ifContainer: IfContainer, data: unknown): boolean;

package/dist/types/internal/compute/collectMemberCallUsage.d.ts

@@ -0,0 +1,8 @@
+import type { Identifier } from "@babel/types";
+import type { EstreeParent } from "@next-core/cook";
+export interface MemberCallUsage {
+    usedArgs: Set<string>;
+    hasNonStaticUsage?: boolean;
+}
+export declare const collectAppGetMenuUsage: (usage: MemberCallUsage, node: Identifier, parent: EstreeParent) => void;
+export declare const collectInstalledAppsHasUsage: (usage: MemberCallUsage, node: Identifier, parent: EstreeParent) => void;

package/dist/types/internal/compute/computeRealProperties.d.ts

@@ -0,0 +1,4 @@
+import { TrackingContextItem } from "./listenOnTrackingContext.js";
+import type { RuntimeContext } from "../interfaces.js";
+export declare function asyncComputeRealProperties(properties: Record<string, unknown> | undefined, runtimeContext: RuntimeContext, trackingContextList?: TrackingContextItem[]): Promise<Record<string, unknown>>;
+export declare function computeRealProperties(properties: Record<string, unknown> | undefined, runtimeContext: RuntimeContext, trackingContextList?: TrackingContextItem[]): Record<string, unknown>;

package/dist/types/internal/compute/computeRealValue.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeContext } from "../interfaces.js";
+import { StateOfUseBrick } from "./getNextStateOfUseBrick.js";
+export interface ComputeOptions {
+    $$lazyForUseBrick?: boolean;
+    $$stateOfUseBrick?: StateOfUseBrick;
+    ignoreSymbols?: boolean;
+}
+export declare function asyncComputeRealValue(value: unknown, runtimeContext: RuntimeContext, internalOptions?: ComputeOptions): Promise<unknown>;
+export declare function computeRealValue(value: unknown, runtimeContext: RuntimeContext, internalOptions?: ComputeOptions): unknown;

package/dist/types/internal/compute/evaluate.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeContext } from "../interfaces.js";
+declare const symbolForRaw: unique symbol;
+declare const symbolForContext: unique symbol;
+export interface PreEvaluated {
+    [symbolForRaw]: string;
+    [symbolForContext]: RuntimeContext;
+}
+export interface EvaluateOptions {
+    lazy?: boolean;
+    isReEvaluation?: boolean;
+    evaluationId?: number;
+}
+export declare function isPreEvaluated(raw: unknown): raw is PreEvaluated;
+export declare function getPreEvaluatedRaw(pre: PreEvaluated): string;
+export declare function shouldDismissMarkingComputed(raw: string | PreEvaluated): boolean;
+export declare function getCookErrorConstructor(error: any): ErrorConstructor;
+export declare function asyncEvaluate(raw: string | PreEvaluated, // string or pre-evaluated object.
+runtimeContext: RuntimeContext, options?: EvaluateOptions): Promise<unknown>;
+export declare function evaluate(raw: string | PreEvaluated, // string or pre-evaluated object.
+runtimeContext: RuntimeContext, options?: EvaluateOptions): Promise<unknown>;
+export {};

package/dist/types/internal/compute/getGeneralGlobals.d.ts

@@ -0,0 +1,12 @@
+import type { MicroApp } from "@next-core/types";
+export interface GeneralGlobalsOptions {
+    collectCoverage?: unknown;
+    widgetId?: string;
+    widgetVersion?: string;
+    app?: PartialMicroApp;
+    appendI18nNamespace?: string;
+    storyboardFunctions?: unknown;
+    isStoryboardFunction?: boolean;
+}
+export type PartialMicroApp = Pick<MicroApp, "id" | "isBuildPush">;
+export declare function getGeneralGlobals(attemptToVisitGlobals: Set<string>, options: GeneralGlobalsOptions): Record<string, unknown>;

package/dist/types/internal/compute/getNextStateOfUseBrick.d.ts

@@ -0,0 +1,16 @@
+export declare enum StateOfUseBrick {
+    INITIAL = 0,
+    USE_BRICK = 1,
+    USE_BRICK_ITEM = 2,
+    USE_BRICK_PROPERTIES = 3,
+    USE_BRICK_EVENTS = 4,
+    USE_BRICK_IF = 5,
+    USE_BRICK_SLOTS = 6,
+    USE_BRICK_SLOTS_ITEM = 7,
+    USE_BRICK_SLOTS_ITEM_BRICKS = 8,
+    USE_BRICK_SLOTS_ITEM_BRICKS_ITEM = 9,
+    USE_BRICK_LIFECYCLE = 10,
+    USE_BRICK_DATA_SOURCE = 11
+}
+export declare function isLazyContentInUseBrick(state: StateOfUseBrick | undefined): boolean;
+export declare function getNextStateOfUseBrick(state: StateOfUseBrick | undefined, isArray?: boolean, key?: string): StateOfUseBrick | undefined;

package/dist/types/internal/compute/getStorageItem.d.ts

@@ -0,0 +1 @@
+export declare function getStorageItem(storageType: "local" | "session"): (name: string) => any;

package/dist/types/internal/compute/getTracks.d.ts

@@ -0,0 +1,5 @@
+export declare function getTracks(value: unknown): {
+    contextNames: false | Set<string>;
+    stateNames: false | Set<string>;
+    formStateNames: false | Set<string>;
+};

package/dist/types/internal/compute/images.d.ts

@@ -0,0 +1,5 @@
+export interface ImagesFactory {
+    get(name: string): string;
+}
+export declare function imagesFactory(appId: string, isBuildPush?: boolean): ImagesFactory;
+export declare function widgetImagesFactory(widgetId: string, widgetVersion?: string): ImagesFactory;

package/dist/types/internal/compute/listenOnTrackingContext.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeBrick } from "../interfaces.js";
+export interface TrackingContextItem {
+    contextNames: string[] | Set<string> | false;
+    stateNames: string[] | Set<string> | false;
+    formStateNames: string[] | Set<string> | false;
+    propName: string;
+    propValue: unknown;
+}
+export declare function listenOnTrackingContext(brick: RuntimeBrick, trackingContextList: TrackingContextItem[]): void;

package/dist/types/internal/compute/markAsComputed.d.ts

@@ -0,0 +1,3 @@
+export declare function markAsComputed(value: unknown): void;
+export declare function hasBeenComputed(object: unknown): boolean;
+export declare function resetAllComputedMarks(): void;

package/dist/types/internal/compute/setProperties.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeContext } from "../interfaces.js";
+export declare function setProperties(bricks: HTMLElement | HTMLElement[], properties: Record<string, unknown>, runtimeContext: RuntimeContext): void;

package/dist/types/internal/compute/setRealProperties.d.ts

@@ -0,0 +1 @@
+export declare function setRealProperties(brick: HTMLElement, realProps: Record<string, unknown> | undefined): void;

package/dist/types/internal/data/CollectContracts.d.ts

@@ -0,0 +1,5 @@
+import { Contract } from "@next-core/types";
+export declare function collectContract(contracts: Contract[] | undefined): void;
+export declare function collectWidgetContract(contracts: Contract[] | undefined): void;
+export declare function clearCollectWidgetContract(): void;
+export declare function getContract(name: string): Contract | undefined;

package/dist/types/internal/data/DataStore.d.ts

@@ -0,0 +1,26 @@
+import type { BrickEventHandlerCallback, ContextConf } from "@next-core/types";
+import { ResolveOptions } from "./resolveData.js";
+import type { AsyncProperties, RuntimeBrick, RuntimeContext } from "../interfaces.js";
+export type DataStoreType = "CTX" | "STATE" | "FORM_STATE";
+export interface DataStoreItem {
+    value: unknown;
+    eventTarget: EventTarget;
+    loaded?: boolean;
+    loading?: Promise<unknown>;
+    load?: (options?: ResolveOptions) => Promise<unknown>;
+}
+export declare class DataStore<T extends DataStoreType = "CTX"> {
+    private readonly type;
+    private readonly data;
+    private readonly changeEventType;
+    private readonly pendingStack;
+    readonly hostBrick?: RuntimeBrick;
+    constructor(type: T, hostBrick?: RuntimeBrick);
+    getValue(name: string): unknown;
+    updateValue(name: string, value: unknown, method: "assign" | "replace" | "refresh" | "load", callback?: BrickEventHandlerCallback, callbackRuntimeContext?: RuntimeContext): void;
+    define(dataConfs: ContextConf[] | undefined, runtimeContext: RuntimeContext, asyncHostProperties?: AsyncProperties): void;
+    onChange(dataName: string, listener: EventListener): void;
+    waitFor(dataNames: string[] | Set<string>): Promise<void>;
+    waitForAll(): Promise<void>;
+    private resolve;
+}

package/dist/types/internal/data/FlowApi.d.ts

@@ -0,0 +1,30 @@
+import { ContractRequest, ContractResponse, ExtField } from "@next-core/types";
+export declare function isFlowApiProvider(provider: string): boolean;
+export declare function getArgsOfFlowApi(provider: string, originalArgs: unknown[], method?: string): Promise<unknown[]>;
+export interface CustomApiDefinition {
+    name: string;
+    namespace: string;
+    version?: string;
+    serviceName?: string;
+    contract?: {
+        endpoint: {
+            ext_fields?: ExtField[];
+            uri: string;
+            method: "POST" | "post" | "PUT" | "put" | "GET" | "get" | "DELETE" | "delete" | "LIST" | "list" | "PATCH" | "patch" | "HEAD" | "head";
+        };
+        request?: ContractRequest;
+        response?: ContractResponse;
+    };
+}
+export interface CustomApiProfile {
+    uri: string;
+    method: string;
+    name: string;
+    namespace: string;
+    serviceName?: string;
+    responseWrapper: boolean;
+    version?: string;
+    isFileType?: boolean;
+    ext_fields?: ExtField[];
+    request?: ContractRequest;
+}

package/dist/types/internal/data/FlowApiProvider.d.ts

@@ -0,0 +1,20 @@
+import { ExtField, ContractRequest } from "@next-core/types";
+import { HttpOptions } from "@next-core/http";
+export declare const FLOW_API_PROVIDER = "core.provider-flow-api";
+export interface CustomApiParams {
+    url: string;
+    originalUri?: string;
+    method?: string;
+    responseWrapper?: boolean;
+    ext_fields?: ExtField[];
+    request?: ContractRequest;
+    isFileType?: boolean;
+}
+export declare function processExtFields(ext_fields: ExtField[], ...args: unknown[]): {
+    data: unknown;
+    options: HttpOptions;
+};
+export declare function hasFileType(request: ContractRequest | undefined): boolean;
+export declare function transformFormData(data: Record<string, unknown> | FormData): FormData;
+export declare function callFlowApi({ url, originalUri, method, responseWrapper, ext_fields, request, isFileType, }: CustomApiParams, ...args: unknown[]): Promise<unknown>;
+export declare function registerFlowApiProvider(): void;

package/dist/types/internal/data/getProviderBrick.d.ts

@@ -0,0 +1 @@
+export declare function getProviderBrick(provider: string): Promise<HTMLElement>;

package/dist/types/internal/data/resolveData.d.ts

@@ -0,0 +1,16 @@
+import type { ResolveConf } from "@next-core/types";
+import type { RuntimeContext } from "../interfaces.js";
+export interface ResolveOptions {
+    /**
+     * Cache mode of resolve.
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
+     *
+     * - `default`: Looks for a matching cache.
+     * - `reload`: Without looking for a matching cache.
+     */
+    cache?: "default" | "reload";
+}
+export declare function resolveData(resolveConf: ResolveConf, runtimeContext: RuntimeContext, options?: ResolveOptions): Promise<unknown>;
+export declare function clearResolveCache(): void;
+export declare function resolveByProvider(brick: Record<string, Function>, useProvider: string, method: string, args: unknown[], options?: ResolveOptions, originalArgs?: unknown[]): Promise<unknown>;

package/dist/types/internal/data/resolveDataStore.d.ts

@@ -0,0 +1,11 @@
+import { ContextConf } from "@next-core/types";
+import { MemberUsage } from "@next-core/utils/storyboard";
+export interface DeferredContext {
+    resolve(): void;
+    reject(e: unknown): void;
+}
+export declare function resolveDataStore(contextConfs: ContextConf[], resolveContext: (contextConf: ContextConf) => Promise<boolean>, keyword?: string): {
+    pendingResult: Promise<void>;
+    pendingContexts: Map<string, Promise<void>>;
+};
+export declare function getDependencyMapOfContext(contextConfs: ContextConf[], keyword?: string): Map<ContextConf, MemberUsage>;

package/dist/types/internal/devtools.d.ts

@@ -0,0 +1,6 @@
+interface DevtoolsHook {
+    emit: (message: unknown) => void;
+    restoreDehydrated: (value: unknown) => unknown;
+}
+export declare function getDevHook(): DevtoolsHook | undefined;
+export {};

package/dist/types/internal/enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum RenderTag {
+    ROOT = 1,
+    BRICK = 2
+}

package/dist/types/internal/historyExtended.d.ts

@@ -0,0 +1,58 @@
+import { History, LocationDescriptor } from "history";
+export declare function getUserConfirmation(message: string, callback: (result: boolean) => void): void;
+export declare function historyExtended(browserHistory: History<NextHistoryState>): ExtendedHistory;
+export interface NextHistoryState {
+    notify?: boolean;
+    from?: LocationDescriptor<NextHistoryState>;
+}
+/**
+ * 扩展的系统会话对象。
+ */
+export interface ExtendedHistory {
+    /**
+     * 更新指定的 query 参数，会保留当前其它 query 参数，往浏览器会话历史栈中推入一条新记录。
+     */
+    pushQuery: UpdateQueryFunction;
+    /**
+     * 更新指定的 query 参数，会保留当前其它 query 参数，替换浏览器会话历史栈中最新的一条记录。
+     */
+    replaceQuery: UpdateQueryFunction;
+    /** {@inheritDoc UpdateAnchorFunction} */
+    pushAnchor: UpdateAnchorFunction;
+    /** 重载当前会话，即触发页面重新渲染。与 location.reload() 不同，它不会触发浏览器页面的重载。 */
+    reload: (callback?: (blocked: boolean) => void) => void;
+    /** @internal */
+    setBlockMessage: (message: string | undefined) => void;
+    /** @internal */
+    getBlockMessage: () => string | undefined;
+    /** 取消之前设置的阻止页面离开信息的设置。 */
+    unblock: () => void;
+    /** 推入一条记录。*/
+    push: (location: LocationDescriptor<NextHistoryState>, state?: NextHistoryState, callback?: (blocked: boolean) => void) => void;
+    /** 替换一条记录。*/
+    replace: (location: LocationDescriptor<NextHistoryState>, state?: NextHistoryState, callback?: (blocked: boolean) => void) => void;
+}
+/**
+ * 更新指定的 query 参数。
+ *
+ * @param query - 要更新的 query 参数。
+ * @param options - 选项。
+ */
+export type UpdateQueryFunction = (query: Record<string, unknown>, options?: UpdateQueryOptions, callback?: (blocked: boolean) => void) => void;
+/** 更新 query 参数时的选项 */
+export interface UpdateQueryOptions extends NextHistoryState {
+    /** 额外要更新的 query 参数。 */
+    extraQuery?: Record<string, unknown>;
+    /** 是否同时清除当前的所有其它 query 参数。 */
+    clear?: boolean;
+    /** 是否保留当前 hash 参数。 */
+    keepHash?: boolean;
+}
+/**
+ * 设置指定的 anchor （URL hash）地址，此方法默认不会触发页面重新渲染。
+ * 往浏览器会话历史栈中推入一条新记录。
+ *
+ * @param hash - Hash 地址。
+ * @param state - 会话状态设置。
+ */
+export type UpdateAnchorFunction = (hash: string, state?: NextHistoryState, callback?: (blocked: boolean) => void) => void;

package/dist/types/internal/interfaces.d.ts

@@ -0,0 +1,92 @@
+import type { LegacyCompatibleRuntimeContext } from "@next-core/inject";
+import type { BrickEventHandler, BrickEventsMap, CustomTemplateProxy, CustomTemplateProxyBasicProperty, CustomTemplateProxySlot, SlotsConfOfBricks } from "@next-core/types";
+import type { DataStore } from "./data/DataStore.js";
+import { RenderTag } from "./enums.js";
+export interface RuntimeContext extends LegacyCompatibleRuntimeContext {
+    ctxStore: DataStore<"CTX">;
+    tplStateStoreMap: Map<string, DataStore<"STATE">>;
+    pendingPermissionsPreCheck: (Promise<unknown> | undefined)[];
+    tplStateStoreId?: string;
+    forEachItem?: unknown;
+    appendI18nNamespace?: string;
+}
+export type AsyncProperties = Promise<Record<string, unknown>>;
+export interface ElementHolder {
+    element?: HTMLElement | null;
+}
+export interface RenderRoot extends BaseRenderNode {
+    tag: RenderTag.ROOT;
+    container?: HTMLElement | DocumentFragment;
+    createPortal: HTMLElement | DocumentFragment | (() => HTMLElement | DocumentFragment);
+}
+export interface RenderBrick extends BaseRenderNode, RuntimeBrick {
+    tag: RenderTag.BRICK;
+    return: RenderNode;
+    hasTrackingControls?: boolean;
+}
+export interface BaseRenderNode {
+    tag: RenderTag;
+    child?: RenderBrick;
+    sibling?: RenderBrick;
+    return?: RenderNode | null;
+    childElements?: HTMLElement[];
+}
+export type RenderNode = RenderRoot | RenderBrick;
+export interface RuntimeBrick {
+    type: string;
+    properties?: Record<string, unknown>;
+    events?: BrickEventsMap;
+    slotId?: string;
+    element?: RuntimeBrickElement | null;
+    iid?: string;
+    runtimeContext: RuntimeContext;
+    tplHostMetadata?: TemplateHostMetadata;
+    portal?: boolean;
+    ref?: string;
+}
+export type MetaInfoOfEventListener = [
+    string,
+    null | undefined,
+    BrickEventHandler
+];
+export type RememberedEventListener = [string, EventListener];
+export interface RuntimeBrickElement extends HTMLElement {
+    $$typeof?: "brick" | "provider" | "custom-template" | "native" | "invalid";
+    /** Meta info of listeners, for devtools only */
+    $$eventListeners?: MetaInfoOfEventListener[];
+    /** Remembered listeners for unbinding */
+    $$listeners?: RememberedEventListener[];
+    /** Remembered proxy listeners for unbinding */
+    $$proxyListeners?: RememberedEventListener[];
+    /** Find element by ref in a custom template */
+    $$getElementByRef?: (ref: string) => HTMLElement | null | undefined;
+    $$tplStateStore?: DataStore<"STATE">;
+}
+export interface TemplateHostMetadata {
+    internalBricksByRef: Map<string, RuntimeBrick>;
+    tplStateStoreId: string;
+    proxy?: CustomTemplateProxy;
+}
+export type TemplateHostBrick = RuntimeBrick & {
+    tplHostMetadata: TemplateHostMetadata;
+};
+export interface TemplateHostContext {
+    reversedProxies: ReversedProxies;
+    asyncHostProperties?: AsyncProperties;
+    externalSlots?: SlotsConfOfBricks;
+    tplStateStoreId: string;
+    hostBrick: TemplateHostBrick;
+}
+interface ReversedProxies {
+    properties: Map<string, ReversedPropertyProxy[]>;
+    slots: Map<string, ReversedSlotProxy[]>;
+}
+interface ReversedPropertyProxy {
+    from: string;
+    to: CustomTemplateProxyBasicProperty;
+}
+interface ReversedSlotProxy {
+    from: string;
+    to: CustomTemplateProxySlot;
+}
+export {};

package/dist/types/internal/loadBootstrapData.d.ts

@@ -0,0 +1,10 @@
+import type { BootstrapData, RuntimeStoryboard } from "@next-core/types";
+import { MenuRawData } from "./menu/interfaces.js";
+export declare function loadBootstrapData(): Promise<BootstrapData>;
+interface RuntimeMicroAppStandaloneData {
+    userConfig?: Record<string, unknown>;
+    injectMenus?: MenuRawData[];
+}
+export declare function safeGetRuntimeMicroAppStandalone(appId: string): Promise<RuntimeMicroAppStandaloneData | undefined>;
+export declare function fulfilStoryboard(storyboard: RuntimeStoryboard): Promise<void>;
+export {};

package/dist/types/internal/loadCheckLogin.d.ts

@@ -0,0 +1 @@
+export declare function loadCheckLogin(): Promise<void>;

package/dist/types/internal/matchPath.d.ts

@@ -0,0 +1,18 @@
+import type { LegacyCompatibleRuntimeContext } from "@next-core/inject";
+/**
+ * Public API for matching a URL pathname to a path.
+ */
+export declare function matchPath(pathname: string, options: MatchPathOptions): MatchResult | null;
+export declare function toPath(path: string, pathParams?: Record<string, unknown>): string;
+interface CompileOptions {
+    end?: boolean;
+    strict?: boolean;
+    sensitive?: boolean;
+}
+interface MatchOptions {
+    path: string | string[];
+    exact?: boolean;
+}
+export type MatchPathOptions = MatchOptions & CompileOptions;
+export type MatchResult = Exclude<LegacyCompatibleRuntimeContext["match"], undefined>;
+export {};

package/dist/types/internal/matchRoutes.d.ts

@@ -0,0 +1,9 @@
+import type { RouteConf } from "@next-core/types";
+import { MatchResult } from "./matchPath.js";
+import type { RuntimeContext } from "./interfaces.js";
+type MatchRoutesResult = {
+    match: MatchResult;
+    route: RouteConf;
+} | "missed" | "unauthenticated";
+export declare function matchRoutes(routes: RouteConf[], runtimeContext: RuntimeContext): Promise<MatchRoutesResult>;
+export {};

package/dist/types/internal/matchStoryboard.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeStoryboard } from "@next-core/types";
+export declare function matchStoryboard(storyboards: RuntimeStoryboard[], pathname: string): RuntimeStoryboard | undefined;
+/**
+ * We say it's an outside app when at least one of the below conditions are true:
+ *   - target app is not found.
+ *   - current app is non-standalone mode and target app is standalone mode.
+ *
+ * Note: when current app is standalone mode, other apps will not be found.
+ */
+export declare function isOutsideApp(storyboard: RuntimeStoryboard | undefined): boolean | undefined;

package/dist/types/internal/mediaQuery.d.ts

@@ -0,0 +1,14 @@
+import EventTarget from "@ungap/event-target";
+export interface Media {
+    breakpoint?: MediaBreakpoint;
+}
+export declare enum MediaBreakpoint {
+    xLarge = "xLarge",
+    large = "large",
+    medium = "medium",
+    small = "small",
+    xSmall = "xSmall"
+}
+export declare const mediaBreakpointMinWidthMap: Map<MediaBreakpoint, string | number>;
+export declare const mediaEventTarget: EventTarget;
+export declare const getMedia: () => Media;

package/dist/types/internal/menu/computeMenuData.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeContext } from "../interfaces.js";
+import type { RuntimeMenuItemRawData, RuntimeMenuRawData } from "./interfaces.js";
+type RuntimeMenuRestRawData = Omit<RuntimeMenuRawData, "app" | "items">;
+type RuntimeMenuItemRestRawData = Omit<RuntimeMenuItemRawData, "children">;
+export declare function computeMenuData<T extends RuntimeMenuRestRawData | RuntimeMenuItemRestRawData>(data: T, overrideAppId: string, runtimeContext: RuntimeContext): Promise<T>;
+export declare function computeMenuItems(items: RuntimeMenuItemRawData[], runtimeContext: RuntimeContext): Promise<RuntimeMenuItemRawData[]>;
+export {};

package/dist/types/internal/menu/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const symbolAppId: unique symbol;
+export declare const symbolMenuI18nNamespace: unique symbol;
+export declare const symbolOverrideApp: unique symbol;

package/dist/types/internal/menu/fetchMenuById.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeContext } from "../interfaces.js";
+export declare function getMenuById(menuId: string): unknown;
+export declare function fetchMenuById(menuId: string, runtimeContext: RuntimeContext): Promise<void>;

package/dist/types/internal/menu/fetchMenuTitle.d.ts

@@ -0,0 +1,2 @@
+import type { MenuRawData } from "./interfaces.js";
+export declare function fetchMenuTitle(menuData: Pick<MenuRawData, "title" | "titleDataSource">): Promise<string | undefined>;

package/dist/types/internal/menu/getMenusOfStandaloneApp.d.ts

@@ -0,0 +1,2 @@
+import { MenuRawData } from "./interfaces.js";
+export declare function getMenusOfStandaloneApp(menuId: string, appId: string): MenuRawData[];