@omnia/fx 7.11.32 → 7.12.1

package/internal-do-not-import-from-here/ux/layoutcanvas/renderer/LayoutBlockRendererHelper.d.ts

@@ -1,10 +1,9 @@
-import { VueComponentBase, LayoutCanvasStore, BlockInstance, LayoutMediaContext, LayoutFileContext } from "@omnia/fx/ux";
-import { Block, GuidValue, IBlockInstance } from "@omnia/fx/models";
-import { ILayoutBlockRendererHelper } from "./ILayoutBlockRendererHelper";
+import { LayoutMediaContext, LayoutFileContext } from "@omnia/fx/ux";
+import { GuidValue, IBlockInstance } from "@omnia/fx/models";
 import { ISettingsStorage } from "../../../services";
-export default class LayoutBlockRendererHelper extends VueComponentBase implements ILayoutBlockRendererHelper {
+export interface LayoutBlockRendererHelperProps {
     blockId: string;
-    blockRenderer: () => JSX.Element;
+    blockRenderer: () => VueTsxSupport.JSX.Element;
     settingsStorage: ISettingsStorage<any>;
     layoutProvider?: string;
     blockManifestId?: GuidValue;
@@ -14,18 +13,10 @@ export default class LayoutBlockRendererHelper extends VueComponentBase implemen
     mediaContext: LayoutMediaContext;
     fileContext: LayoutFileContext;
     onBlockInstanceCreated?: (blockInstance: IBlockInstance) => void;
-    private subscriptionHandler;
-    layoutMediaContext: LayoutMediaContext;
-    layoutFileContext: LayoutFileContext;
-    layoutStore: LayoutCanvasStore;
-    blockInstance: BlockInstance;
-    private subscribeSettingUpdated;
-    private blockSettingsManager;
-    private readyToRender;
-    block: Partial<Block>;
-    mounted(): void;
-    beforeDestroy(): void;
-    created(): void;
-    private handleSettingsChanged;
-    render(): JSX.Element;
 }
+declare const LayoutBlockRendererHelper: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<LayoutBlockRendererHelperProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LayoutBlockRendererHelperProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<LayoutBlockRendererHelperProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LayoutBlockRendererHelperProps, never>;
+});
+export default LayoutBlockRendererHelper;

package/internal-do-not-import-from-here/ux/layoutcanvas/renderer/LayoutRendererCanvas.d.ts

@@ -1,41 +1,15 @@
-import { LayoutItem, LayoutRendererCanvasApi, LayoutRendererCanvasStyles } from "@omnia/fx/models";
-import { BlockCatalogStore, LayoutCanvasStore, ThemingRenditionManager } from "../";
-import { LayoutFileContext, LayoutMediaContext, ThemeStore, VueComponentBase } from "../..";
-import { IWebComponentInstance, SubscriptionHandler } from "../../..";
-import { MediaPickerService } from "../../../services";
-import { BlockTitleSettingsStore, DirectionRuleStore } from "../../../stores";
-import { AnchorLink } from "../../AnchorLink";
-import { ILayoutRendererCanvas } from "./ILayoutRendererCanvas";
+import { LayoutRendererCanvasApi, LayoutRendererCanvasStyles } from "@omnia/fx/models";
 import "./LayoutRendererCanvas.css";
-export default class LayoutRendererCanvas extends VueComponentBase implements IWebComponentInstance, ILayoutRendererCanvas {
+export interface LayoutRendererCanvasProps {
     designRender?: boolean;
     styles?: Partial<typeof LayoutRendererCanvasStyles>;
     getApi: (inst: LayoutRendererCanvasApi) => void;
     provider: string;
     disableScrollCompensation: boolean;
-    layoutStore: LayoutCanvasStore;
-    mediaContext: LayoutMediaContext;
-    fileContext: LayoutFileContext;
-    blockTitleSettingsStore: BlockTitleSettingsStore;
-    anchorLink: AnchorLink;
-    layoutItemStore: BlockCatalogStore;
-    subscriptionHandler: SubscriptionHandler;
-    mediaPickerService: MediaPickerService;
-    themeStore: ThemeStore;
-    themingRenditionManager: ThemingRenditionManager;
-    directionRuleStore: DirectionRuleStore;
-    private LayoutRendererCanvasClasses;
-    private timeWatchId;
-    private enableVerticalAlign;
-    private layoutItemDelegator;
-    private delegatedSections;
-    beforeCreate(): void;
-    created(): void;
-    beforeDestroy(): void;
-    mounted(): void;
-    ensureBlockTitleSettingsForLayout(): void;
-    private get backgroundImage();
-    private onContainerUpdated;
-    renderLayout(layoutItem: LayoutItem): VueTsxSupport.JSX.Element[];
-    render(): VueTsxSupport.JSX.Element;
 }
+declare const LayoutRendererCanvas: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<LayoutRendererCanvasProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LayoutRendererCanvasProps, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<LayoutRendererCanvasProps, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<LayoutRendererCanvasProps, never>;
+});
+export default LayoutRendererCanvas;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/LayoutManager.d.ts

@@ -1,7 +1,7 @@
 import { ImportLayoutResult, Block, Section } from "../../../models";
 import { Layout, LayoutItem } from "@omnia/fx-models";
 import { LayoutCanvasStore } from "..";
-import { LayoutDefinitionValidationOptions } from "./LayoutDefinitionValidator";
+import type { LayoutDefinitionValidationOptions } from "./LayoutDefinitionValidator";
 /**
  * Manager to handle the layout
  */
@@ -16,7 +16,6 @@ export declare class LayoutManager {
      * Validates and repairs a JSON layout against the current canvas before it
      * can be applied. Import mode is the safe default for compatibility with
      * the original API; direct edits opt into current-layout mode explicitly.
-     * Imports a layout and applies all the ids from the current page layout
      * @param pageLayoutDataString to import
      */
     static importLayoutFromJsonString(layoutCanvasStore: LayoutCanvasStore, pageLayoutDataString: string, options?: LayoutDefinitionValidationOptions): ImportLayoutResult;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/ThemingRenditionManager.d.ts

@@ -1,5 +1,5 @@
-import { Block, LayoutSettings, SectionSettings, Section, ThemeStyling, ThemeDefinition } from "../../../models";
-import { ThemeStore, ITheming } from "../../theming";
+import { Block, LayoutSettings, Section, SectionSettings, ThemeDefinition, ThemeStyling } from "../../../models";
+import { ITheming, ThemeStore } from "../../theming";
 export declare class ThemingRenditionManager {
     private themeReferences;
     getThemeTargetIdBlock(block: Block, layoutSettings: LayoutSettings, parentSettings: SectionSettings, inheritedThemeTargetId: string, blockThemeDefinition: ThemeDefinition): string;
@@ -10,6 +10,7 @@ export declare class ThemingRenditionManager {
     garbagecollectNonLayoutThemes(themeStore: ThemeStore, currentLayoutId: string): void;
     registerSectionTheme(themeStore: ThemeStore, section: Section, layoutId: string): void;
     registerBlockTheme(themeStore: ThemeStore, block: Block, layoutId: string): void;
+    unregisterBlockTheme(themeStore: ThemeStore, blockId: string): void;
     private registerCustomTheme;
     private registerThemeDefinition;
     registerLayoutTheme(themeStore: ThemeStore, layoutSettings: LayoutSettings, layoutId: string, layoutThemeDefinition: ThemeDefinition, blockThemeDefinition: ThemeDefinition): void;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsdesigner/StepperSectionDesigner.d.ts

@@ -1,62 +1,6 @@
 import { Section, SectionItem, SteppedSectionItemSettings, StepperSectionSettings } from "../../../../models";
-import { LayoutCanvasStore, VueComponentBase, MultilingualContext } from "../../..";
-import { MultilingualStore } from "../../../../stores";
-import { OmniaContext, SubscriptionHandler } from "../../../..";
-import { OmniaUxLocalization } from "../../../UxModels";
-import { DynamicStateStore } from "../../";
-import { AnchorLink } from "../../../AnchorLink";
 export interface StepperSectionDesignerProps {
     section: Section<StepperSectionSettings>;
-    renderSectionItem: (sectionItem: SectionItem<SteppedSectionItemSettings>) => JSX.Element | Array<JSX.Element>;
-}
-export declare class StepperSectionDesigner extends VueComponentBase<StepperSectionDesignerProps> {
-    section: Section<StepperSectionSettings>;
-    renderSectionItem: (sectionItem: SectionItem<SteppedSectionItemSettings>) => JSX.Element | Array<JSX.Element>;
-    multilingualStore: MultilingualStore;
-    selectedStepStateStore: DynamicStateStore;
-    omniaUxLoc: OmniaUxLocalization;
-    layoutCanvasStore: LayoutCanvasStore;
-    subscriptionHandler: SubscriptionHandler;
-    omniaContext: OmniaContext;
-    anchorLink: AnchorLink;
-    multilingualContext: MultilingualContext;
-    private stepperCurrentStep;
-    private readyToSetVisible;
-    private isShowOverlay;
-    private editorDesignModeStepperKey;
-    private initialAnchorLinkResolved;
-    private internalValidator;
-    created(): void;
-    beforeDestroy(): void;
-    private hasValidAnchorLinkSettings;
-    private handleTokenExistsOnSpfx;
-    private getIndexByAnchorName;
-    private handleAnchorLink;
-    private getDefaultLabel;
-    private getPreferredLabel;
-    private getCustomAnchorName;
-    private silentNavigateIfNeeded;
-    private renderStepLabel;
-    private getSpfxPath;
-    private getAnchorName;
-    get items(): SectionItem<SteppedSectionItemSettings>[];
-    private get inLayoutDesignMode();
-    private getStepperKeyByVerticalMode;
-    private getScrollToStepClassName;
-    private scrollStepperToTop;
-    private getStepTitlePanelTriggerId;
-    private stepTitlePanelTriggerClick;
-    private renderEditableStepTitle;
-    private renderStepperStep;
-    private addStep;
-    private handleToSetOverflowForStepperContent;
-    private handleUIOnStepChanged;
-    private renderStepperContent;
-    private renderAddStepButton;
-    private renderAnchorElements;
-    renderPagingItem(): VueTsxSupport.JSX.Element[][];
-    renderStepperItem(index: number, item: SectionItem<SteppedSectionItemSettings>): JSX.Element[];
-    renderHorizontalPaginationMode(): VueTsxSupport.JSX.Element;
-    renderHorizontalMultilineMode(index: number, item: SectionItem<SteppedSectionItemSettings>): (VueTsxSupport.JSX.Element | VueTsxSupport.JSX.Element[])[];
-    render(): VueTsxSupport.JSX.Element;
+    renderSectionItem: (sectionItem: SectionItem<SteppedSectionItemSettings>) => VueTsxSupport.JSX.Element | Array<VueTsxSupport.JSX.Element>;
 }
+export declare const StepperSectionDesigner: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<StepperSectionDesignerProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutBlockRenderer.d.ts

@@ -1,76 +1,17 @@
-import { VNode } from "vue";
-import { Block, BlockLayoutSettings, SectionSettings } from "../../../../models";
-import { ThemingRenditionManager } from "../../";
-import { LayoutItem } from "../../../../models";
-import { LayoutCanvasStore, BlockCatalogStore } from "../../";
-import { VueComponentBaseProps, VueComponentBase, VueComponentBaseEvents } from "../../../VueComponentBase";
-import { SettingsService, MediaPickerService } from "../../../../services";
-import { UserTargetingStore, BlockTitleSettingsStore, MultilingualStore } from "../../../../stores";
-import { SubscriptionHandler } from "../../../..";
-import { BlockInstance, LayoutMediaContext, LayoutFileContext, ThemeStore } from "../../../";
-import { AnchorLink } from "../../../AnchorLink";
-import { OmniaContext } from "../../../../contexts";
+import Vue from "vue";
+import { Block, SectionSettings, LayoutItem } from "../../../../models";
+import { VueComponentBaseProps } from "../../../VueComponentBase";
 export interface BlockRendererProps extends VueComponentBaseProps {
     block: Block;
     parentContainer: LayoutItem;
     settings: SectionSettings;
+    disableHeightReservation?: boolean;
 }
-interface BlockRendererEvents extends VueComponentBaseEvents {
-    onGetBlock?: {
-        blockGetterFunc: (block: Block) => void;
-    };
-    onBlockInstanceCreated?: BlockInstance;
-    onBlockInstanceCacheKeyUpdated?: BlockInstance;
-}
-export declare class LayoutBlockRenderer extends VueComponentBase<BlockRendererProps, BlockRendererEvents> {
+export interface LayoutBlockRendererProps {
     block: Block;
     parentContainer: LayoutItem;
     settings: SectionSettings;
     useClickProtection: boolean;
-    protected settingsService: SettingsService<any>;
-    layoutEditorStore: LayoutCanvasStore;
-    layoutMediaContext: LayoutMediaContext;
-    layoutFileContext: LayoutFileContext;
-    blockTitleSettingsStore: BlockTitleSettingsStore;
-    targetingStore: UserTargetingStore;
-    layoutItemStore: BlockCatalogStore;
-    mediaPickerService: MediaPickerService;
-    themeStore: ThemeStore;
-    themingRenditionManager: ThemingRenditionManager;
-    subscriptionHandler: SubscriptionHandler;
-    omniaContext: OmniaContext;
-    multilingualStore: MultilingualStore;
-    blockInstance: BlockInstance;
-    anchorLink: AnchorLink;
-    private subscriptionPrintHandler;
-    private isHideBlock;
-    private targetCurrentUser;
-    private isEditMode;
-    private isLazyLoad;
-    private isHideBlockInPrint;
-    private isRenderInViewPort;
-    onBlockChanged(): void;
-    beforeCreate(): void;
-    created(): void;
-    private subcribeOnPrint;
-    beforeDestroy(): void;
-    private scrollIntoViewDisabled;
-    private handleAnchorLink;
-    private get backgroundImage();
-    /**
-     * Creates the element
-     * @param h
-     */
-    createElement(): VNode;
-    private getThemeTargetId;
-    private createAnchorElement;
-    private getAnchorName;
-    hideBlock(isHide: boolean): void;
-    checkTargetingValue(settings: BlockLayoutSettings): void;
-    /**
-     * Render
-     * @param h
-     */
-    render(): VueTsxSupport.JSX.Element;
+    disableHeightReservation?: boolean;
 }
-export {};
+export declare const LayoutBlockRenderer: import("vue-tsx-support")._TsxComponentV3<Vue, {}, import("vue-tsx-support").PropsForOutside<LayoutBlockRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutColumnRenderer.d.ts

@@ -1,40 +1,17 @@
 import { ColumnedSectionItemSettings, SectionSettings, SectionItem } from "../../../../models";
-import { LayoutCanvasStore, BlockCatalogStore } from "../../";
-import { VueComponentBaseProps, VueComponentBase } from "../../../VueComponentBase";
-import { SubscriptionHandler } from "../../../..";
-import { MediaPickerService } from "../../../../services";
+import { VueComponentBaseProps } from "../../../VueComponentBase";
 export interface ColumnRendererProps extends VueComponentBaseProps {
     column: SectionItem<ColumnedSectionItemSettings>;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutColumnRenderer extends VueComponentBase<ColumnRendererProps> {
-    layoutEditorStore: LayoutCanvasStore;
-    mediaPickerService: MediaPickerService;
-    blockCatalogStore: BlockCatalogStore;
-    subscriptionHandler: SubscriptionHandler;
+export interface LayoutColumnRendererProps {
     column: SectionItem<ColumnedSectionItemSettings>;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
-    private renderedOnce;
-    private blockInstances;
-    private cacheKeys;
-    private blockSettings;
-    private isHiddenOnPrint;
-    private delegatedSections;
-    private layoutItemDelegator;
-    created(): void;
-    beforeDestroy(): void;
-    private destroyed;
-    private get backgroundImage();
-    private onBlockInstanceCreated;
-    private onBlockInstanceCacheKeyUpdated;
-    /**
-    * Function to render the columns
-    * @param h is the hyperscript reference
-    */
-    private renderChildren;
-    render(): VueTsxSupport.JSX.Element;
+    disableHeightReservation?: boolean;
 }
+export declare const LayoutColumnRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutColumnRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutContentSettle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Watches `el`'s subtree and calls `onSettled` exactly ONCE when its content has settled per the
+ * conditions above (or at the backstop). Returns a dispose function for unmount — disposing
+ * cancels the watch WITHOUT firing the callback.
+ */
+export declare function watchContentSettled(el: HTMLElement, onSettled: () => void): () => void;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutHeightCache.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Perceived-performance helper: remembers the rendered height of layout SECTIONS and BLOCKS in localStorage,
+ * so on a repeat visit the item can reserve that height up-front (a temporary min-height) and avoid the
+ * load-from-0 collapse/jump (CLS) while its content loads. The reservation is RELEASED once content settles
+ * (shorter loads shrink to their true height) and the new height is recorded, so the cache self-corrects.
+ * Sections and blocks use SEPARATE bucket namespaces (keyPrefix vs blockKeyPrefix) so they never collide or
+ * evict each other — see the two public APIs below.
+ *
+ * KEYING: bucketed by BREAKPOINT only; the stable, globally-unique section.id is the per-section key inside.
+ * An earlier version keyed the bucket by the layout DEFINITION id — but for versioned layouts (workspace
+ * home, teamwork, megamenu, profile card, ...) that id is REGENERATED on every load, so the cache key never
+ * matched and the reserve NEVER applied (confirmed via [RESERVE-TRACE]: 40 one-per-load buckets, always
+ * reserved=null). section.id is stable across loads (same id → same height across visits), so this keys
+ * reliably on every layout. The `layoutId` argument is kept for call-site compatibility but is unused.
+ *
+ *  - READ is critical-path safe: one memoized localStorage read per breakpoint bucket; O(1) section lookup.
+ *  - WRITE is off the critical path: buffered, flushed on idle / page-hide.
+ *  - Everything is guarded so a disabled/full localStorage degrades to a no-op.
+ */
+export declare class LayoutHeightCache {
+    private static readonly keyPrefix;
+    private static readonly blockKeyPrefix;
+    private static readonly maxSectionsPerBucket;
+    private memory;
+    private loaded;
+    private dirty;
+    private flushScheduled;
+    private unloadHooked;
+    private storageOk;
+    private migratedOldKeys;
+    private bucketKey;
+    private blockBucketKey;
+    private storageAvailable;
+    /**
+     * One-time cleanup of the obsolete per-layout-definition buckets (format: keyPrefix + "{guid}.{bp}")
+     * and the old MRU index key, so the ~40 orphaned buckets from the old keying don't linger. The new
+     * bucket keys are keyPrefix + "{bp}" (e.g. "...lg") — no extra "." segment.
+     */
+    private migrateOldKeysOnce;
+    private ensureLoaded;
+    /**
+     * Returns the last recorded height (px) for a section, or null if unknown. Critical-path safe.
+     * `layoutId` is accepted for call-site compatibility but unused (see KEYING note above).
+     */
+    getReservedHeight(layoutId: string, breakpointId: string, sectionId: string): number | null;
+    /**
+     * Records the settled height (px) for a section. Buffered + flushed off the critical path.
+     * `layoutId` is accepted for call-site compatibility but unused (see KEYING note above).
+     */
+    recordHeight(layoutId: string, breakpointId: string, sectionId: string, heightPx: number): void;
+    /** Returns the last recorded height (px) for a block, or null if unknown. Critical-path safe. */
+    getReservedBlockHeight(breakpointId: string, blockId: string): number | null;
+    /** Records the settled height (px) for a block. Buffered + flushed off the critical path. */
+    recordBlockHeight(breakpointId: string, blockId: string, heightPx: number): void;
+    private readHeight;
+    private writeHeight;
+    private scheduleFlush;
+    private hookUnload;
+    private flush;
+}

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutSectionRenderer.d.ts

@@ -1,57 +1,11 @@
-import { ThemingRenditionManager } from "../../";
-import { LayoutItem, Section, ILayoutSectionRenderer, LayoutSectionRendererSlots, SectionSettings } from "../../../../models";
-import { VueComponentBaseProps, VueComponentBase } from "../../../VueComponentBase";
-import { ThemeStore } from "../../../";
-import { UserTargetingStore, BlockTitleSettingsStore, DirectionRuleStore } from "../../../../stores";
-import { LayoutCanvasStore } from "../../";
-import { MediaPickerService } from "../../../../services";
+import { LayoutItem, Section } from "../../../../models";
+import { VueComponentBaseProps } from "../../../VueComponentBase";
 export interface LayoutSectionRendererProps extends VueComponentBaseProps {
     parentContainer: LayoutItem;
     section: Section;
     layoutId: string;
     useScrollMargingFix: boolean;
     overridable?: boolean;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutSectionRenderer extends VueComponentBase<LayoutSectionRendererProps> implements ILayoutSectionRenderer {
-    section: Section;
-    parentContainer: LayoutItem;
-    layoutId: string;
-    useScrollMargingFix: boolean;
-    overridable?: boolean;
-    targetingStore: UserTargetingStore;
-    blockTitleSettingsStore: BlockTitleSettingsStore;
-    layoutEditorStore: LayoutCanvasStore;
-    mediaPickerService: MediaPickerService;
-    themeStore: ThemeStore;
-    themingRenditionManager: ThemingRenditionManager;
-    directionRuleStore: DirectionRuleStore;
-    private omniaUxLoc;
-    ensureBackgroundImageHandler: (section: Section) => void;
-    slots: LayoutSectionRendererSlots;
-    private targetCurrentUser;
-    private isEditMode;
-    private isHideBlockInPrint;
-    created(): void;
-    private get backgroundImage();
-    init(): void;
-    onSectionUpdated(): void;
-    updated(): void;
-    checkTargetingValue(settings: SectionSettings): void;
-    /**
-    * Function to render the columns
-    * @param h is the hyperscript reference
-    */
-    private createColumnMarkup;
-    /**
-   * Function to render the tabs
-   * @param h is the hyperscript reference
-   */
-    private createTabMarkup;
-    /**
-      * Function to render the tabs
-      * @param h is the hyperscript reference
-      */
-    private createStepperMarkup;
-    private renderSectionTitle;
-    render(): VueTsxSupport.JSX.Element;
-}
+export declare const LayoutSectionRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutSectionRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutSectionStepperRenderer.d.ts

@@ -1,18 +1,9 @@
-import { OmniaUxLocalization } from "../../..";
-import { Section, StepperSectionSettings } from "../../../../models";
-import { VueComponentBase } from "../../../VueComponentBase";
+import { Section } from "../../../../models";
 export interface LayoutSectionStepperRendererProps {
     section: Section;
     layoutId: string;
     useScrollMargingFix: boolean;
     themeTargetId?: string;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutSectionStepperRenderer extends VueComponentBase<LayoutSectionStepperRendererProps> {
-    section: Section<StepperSectionSettings>;
-    layoutId: string;
-    useScrollMargingFix: boolean;
-    omniaUxLoc: OmniaUxLocalization;
-    created(): void;
-    private renderSectionItem;
-    render(): VueTsxSupport.JSX.Element;
-}
+export declare const LayoutSectionStepperRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutSectionStepperRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutSectionTabRenderer.d.ts

@@ -1,58 +1,15 @@
-import { Section, SectionItem, TabbedSectionItemSettings } from "../../../../models";
-import { LayoutCanvasStore } from "../../";
-import { MultilingualStore } from "../../../../stores";
-import { VueComponentBase } from "../../../VueComponentBase";
-import { SubscriptionHandler } from "@omnia/fx";
-import { DynamicStateStore } from "../../";
-import { AnchorLink } from "../../../AnchorLink";
-import { OmniaContext } from "../../../../contexts";
+import { Section } from "../../../../models";
 export interface SectionTabRendererProps {
     section: Section;
     layoutId: string;
     useScrollMargingFix: boolean;
     themeTargetId?: string;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutSectionTabRenderer extends VueComponentBase<SectionTabRendererProps> {
-    layoutCanvasStore: LayoutCanvasStore;
-    multilingualStore: MultilingualStore;
-    tabStateStore: DynamicStateStore;
-    subscriptionHandler: SubscriptionHandler;
-    omniaContext: OmniaContext;
-    anchorLink: AnchorLink;
-    private selectedTabIndex;
-    private selectedAccordionIndex;
-    private currentSectionId;
-    private isEditMode;
-    private initialAnchorLinkResolved;
-    private VK_ENTER;
-    private subscriptionPrintHandler;
-    private isAccordionManualClicked;
+export interface LayoutSectionTabRendererProps {
     section: Section;
     layoutId: string;
     useScrollMargingFix: boolean;
-    created(): void;
-    beforeDestroy(): void;
-    private subscribeOnPrint;
-    private handleAnchorLink;
-    updated(): void;
-    private getDefaultLabel;
-    private getPreferredLabel;
-    private getCustomAnchorName;
-    get selectedTab(): SectionItem<TabbedSectionItemSettings>;
-    onSelectTab(index: number): void;
-    onSelectAccordion(val: any): void;
-    private silentNavigateIfNeeded;
-    hasTabIcon(tab: SectionItem<TabbedSectionItemSettings>): boolean;
-    private hasAnyTabIcon;
-    private showIconAndTextMode;
-    renderLabelAndIcon(tab: SectionItem<TabbedSectionItemSettings>, itemId: string, ariaExpandedStatus: string): VueTsxSupport.JSX.Element;
-    private isSelectedAccordionIndex;
-    private ensureValueAccordion;
-    private renderAnchorElements;
-    renderAccordion(): VueTsxSupport.JSX.Element;
-    renderTabTitle(tab: SectionItem<TabbedSectionItemSettings>): VueTsxSupport.JSX.Element;
-    renderIcon(tab: SectionItem<TabbedSectionItemSettings>): VueTsxSupport.JSX.Element;
-    renderTab(tab: SectionItem<TabbedSectionItemSettings>, tabIndex: number): VueTsxSupport.JSX.Element;
-    renderTabs(): VueTsxSupport.JSX.Element;
-    render(): VueTsxSupport.JSX.Element;
+    disableHeightReservation?: boolean;
 }
+export declare const LayoutSectionTabRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutSectionTabRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutStepRenderer.d.ts

@@ -1,30 +1,17 @@
 import { SectionSettings, SectionItem, TabbedSectionItemSettings } from "../../../../models";
-import { LayoutCanvasStore } from "../../";
-import { VueComponentBase } from "../../../VueComponentBase";
-import { MediaPickerService } from "../../../../services";
-import { AnchorLink } from "../../../AnchorLink";
 export interface StepRendererProps {
     step: SectionItem;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutStepRenderer extends VueComponentBase<StepRendererProps> {
-    layoutEditorStore: LayoutCanvasStore;
-    mediaPickerService: MediaPickerService;
-    anchorLink: AnchorLink;
+export interface LayoutStepRendererProps {
     step: SectionItem<TabbedSectionItemSettings>;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
     designRender?: boolean;
-    private fallbackRenderCache;
-    private blockSettings;
-    private blockInstances;
-    private renderedOnce;
-    created(): void;
-    private get backgroundImage();
-    private onBlockInstanceCreated;
-    private renderChildren;
-    render(): VueTsxSupport.JSX.Element;
+    disableHeightReservation?: boolean;
 }
+export declare const LayoutStepRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutStepRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutTabRenderer.d.ts

@@ -1,30 +1,17 @@
 import { SectionSettings, SectionItem, TabbedSectionItemSettings } from "../../../../models";
-import { LayoutCanvasStore } from "../../";
-import { VueComponentBase } from "../../../VueComponentBase";
-import { MediaPickerService } from "../../../../services";
-import { AnchorLink } from "../../../AnchorLink";
 export interface TabRendererProps {
     tab: SectionItem;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
+    disableHeightReservation?: boolean;
 }
-export declare class LayoutTabRenderer extends VueComponentBase<TabRendererProps> {
-    layoutEditorStore: LayoutCanvasStore;
-    mediaPickerService: MediaPickerService;
-    anchorLink: AnchorLink;
+export interface LayoutTabRendererProps {
     tab: SectionItem<TabbedSectionItemSettings>;
     settings: SectionSettings;
     layoutId: string;
     useScrollMargingFix: boolean;
     designRender?: boolean;
-    private fallbackRenderCache;
-    private blockSettings;
-    private blockInstances;
-    private renderedOnce;
-    created(): void;
-    private get backgroundImage();
-    private onBlockInstanceCreated;
-    private renderChildren;
-    render(): VueTsxSupport.JSX.Element;
+    disableHeightReservation?: boolean;
 }
+export declare const LayoutTabRenderer: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<LayoutTabRendererProps, never>, any, any, any>;

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/styles/SharedRendererStyles.css.d.ts

@@ -16,28 +16,29 @@ export declare const SharedRendererStyles: {
     };
     block: {
         createMediaBreakPointForDevice(blockSettings: BlockLayoutSettings, deviceBreakPoint: DisplayBreakPoint): types.NestedCSSProperties;
-        container: (sectionSettings: SectionSettings, blockSettings: BlockLayoutSettings) => string;
+        container: (sectionSettings: SectionSettings, blockSettings: BlockLayoutSettings, cacheEnabled?: boolean) => string;
         clickProtectionOverlay: string;
         createMediaBreakPointBlockForDevice(blockSettings: BlockLayoutSettings, deviceBreakPoint: DisplayBreakPoint): types.NestedCSSProperties;
     };
     column: {
-        getStylesFromSettings(columnSettings: ColumnedSectionItemSettings, backgroundUrl: string, sectionSettings: SectionSettings): string;
-        getStylesForMarginCollaps(sectionSettings: SectionSettings): string;
+        getStylesFromSettings(columnSettings: ColumnedSectionItemSettings, backgroundUrl: string, sectionSettings: SectionSettings, cacheEnabled?: boolean): string;
+        getStylesForMarginCollaps(sectionSettings: SectionSettings, cacheEnabled?: boolean): string;
         container: (sectionSettings: SectionSettings, blockSettings: BlockLayoutSettings) => string;
         hideContainer: (items: Array<LayoutItem>, isEditMode: boolean) => string;
         triggerHideContainer: (isEditMode: boolean, isHidden: boolean) => string;
     };
     section: {
-        sectionAlignmentContainer: (sectionSettings: SectionSettings) => string;
+        hideWhenAllBlocksHidden: string;
+        sectionAlignmentContainer: (sectionSettings: SectionSettings, cacheEnabled?: boolean) => string;
         columnWrapper: string;
         backgroundWrapperImage: string;
         getStyleStringForTitle: (settings: SectionSettings) => string;
         getTitleContentClass: (settings: SectionSettings) => string;
         adjustScrollCompensation: (extra: number) => void;
         getStylesFromSettings: (settings: SectionSettings, useScrollMargingFix: boolean) => string;
-        getStylesForSpacingInContainer(sectionSettings: SectionSettings, fullHeight: boolean): string;
+        getStylesForSpacingInContainer(sectionSettings: SectionSettings, fullHeight: boolean, cacheEnabled?: boolean): string;
         createMediaBreakPointForDevice(sectionSettings: SectionSettings, deviceBreakPoint: DisplayBreakPoint, ignoreHiddenBreakpoints?: boolean): types.NestedCSSProperties;
-        getStylesForMarginCollapsAndSpacing(sectionSettings: SectionSettings, ignoreHiddenBreakpoints?: boolean): string;
+        getStylesForMarginCollapsAndSpacing(sectionSettings: SectionSettings, cacheEnabled?: boolean, ignoreHiddenBreakpoints?: boolean): string;
         sectionDisplayFlexDesignMode: string;
         sectionDisplayBlockDesignMode: string;
         reusingContentMsg: string;