@itwin/saved-views-react 0.4.1 → 0.5.0

package/lib/applySavedView.d.ts

@@ -0,0 +1,64 @@
+import { ViewState, type IModelConnection, type Viewport } from "@itwin/core-frontend";
+import { type SavedViewRepresentation } from "@itwin/saved-views-client";
+export interface ApplySavedViewSettings {
+    /**
+     * Strategy to use when other setting does not specify one. By default, viewport is reset to default state and then
+     * all captured Saved View data is applied on top.
+     * @default "apply"
+     *
+     * @example
+     * await applySavedView(iModel, viewport, savedView, { all: "keep", viewState: "apply" });
+     */
+    all?: ApplyStrategy | undefined;
+    /**
+     * How to handle captured {@link ViewState} data. The default behavior is to generate a new `ViewState` object and
+     * apply it to viewport.
+     *
+     * You can optionally provide a pre-made `ViewState` instance to conserve resources. It is usually obtained from
+     * {@link createViewState} result.
+     *
+     * @example
+     * import { applySavedView, createViewState } from "@itwin/saved-views-react";
+     *
+     * const viewState = await createViewState(iModel, savedView);
+     * await Promise.all([
+     *   applySavedView(iModel, viewport1, savedView, { viewState }),
+     *   applySavedView(iModel, viewport2, savedView, { viewState }),
+     * ]);
+     */
+    viewState?: Exclude<ApplyStrategy, "reset"> | ViewState | undefined;
+    /**
+     * How to handle visibility of models and categories that exist in iModel but are not captured in Saved View data. Has
+     * effect only when `modelAndCategoryVisibility` strategy is set to `"apply"`.
+     * @default "hidden"
+     */
+    modelAndCategoryVisibilityFallback?: "visible" | "hidden" | undefined;
+    /** How to handle captured element emphasis data. In default state emphasis is turned off. */
+    emphasis?: ApplyStrategy | undefined;
+    /**
+     * How to handle captured {@link Viewport.perModelCategoryVisibility} data. In default state no overrides are present.
+     */
+    perModelCategoryVisibility?: ApplyStrategy | undefined;
+}
+/**
+ * Controls how viewport state is going to be altered.
+ *
+ * * `"apply"` – Apply captured Saved View state. Falls back to `"reset"` on failure (e.g. missing Saved View data).
+ * * `"reset"` – Reset to the default viewport state
+ * * `"keep"` – Keep the current viewport state
+ */
+type ApplyStrategy = "apply" | "reset" | "keep";
+/**
+ * Updates {@linkcode viewport} state to match captured Saved View.
+ *
+ * @example
+ * // Optionally, you can create and manage ViewState object yourself to avoid redundant work,
+ * // e.g. when applying the same Saved View to multiple viewports
+ * const viewState = await createViewState(iModel, savedView);
+ * await Promise.all([
+ *   applySavedView(iModel, firstViewport, savedView, { viewState }),
+ *   applySavedView(iModel, secondViewport, savedView, { viewState }),
+ * ]);
+ */
+export declare function applySavedView(iModel: IModelConnection, viewport: Viewport, savedView: Pick<SavedViewRepresentation, "savedViewData" | "extensions">, settings?: ApplySavedViewSettings | undefined): Promise<void>;
+export {};

package/lib/applySavedView.js

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { ViewState } from "@itwin/core-frontend";
+import { createViewState } from "./createViewState.js";
+import { extensionHandlers } from "./translation/SavedViewsExtensionHandlers.js";
+/**
+ * Updates {@linkcode viewport} state to match captured Saved View.
+ *
+ * @example
+ * // Optionally, you can create and manage ViewState object yourself to avoid redundant work,
+ * // e.g. when applying the same Saved View to multiple viewports
+ * const viewState = await createViewState(iModel, savedView);
+ * await Promise.all([
+ *   applySavedView(iModel, firstViewport, savedView, { viewState }),
+ *   applySavedView(iModel, secondViewport, savedView, { viewState }),
+ * ]);
+ */
+export async function applySavedView(iModel, viewport, savedView, settings = {}) {
+    const defaultStrategy = settings.all ?? "apply";
+    if ((settings.viewState ?? defaultStrategy) !== "keep") {
+        if (settings.viewState instanceof ViewState) {
+            viewport.changeView(settings.viewState);
+        }
+        else {
+            const { modelAndCategoryVisibilityFallback } = settings;
+            const viewState = await createViewState(iModel, savedView.savedViewData, { modelAndCategoryVisibilityFallback });
+            viewport.changeView(viewState);
+        }
+    }
+    const extensions = new Map(savedView.extensions?.map(({ extensionName, data }) => [extensionName, data]));
+    const processExtension = (extensionHandler, strategy = defaultStrategy) => {
+        if (strategy === "keep") {
+            return;
+        }
+        extensionHandler.reset(viewport);
+        if (strategy === "apply") {
+            const extensionData = extensions.get(extensionHandler.extensionName);
+            if (extensionData) {
+                extensionHandler.apply(extensionData, viewport);
+            }
+        }
+    };
+    processExtension(extensionHandlers.emphasizeElements, settings.emphasis);
+    processExtension(extensionHandlers.perModelCategoryVisibility, settings.perModelCategoryVisibility);
+}

package/lib/captureSavedViewData.d.ts

@@ -2,13 +2,8 @@ import { Id64Array } from "@itwin/core-bentley";
 import { type IModelConnection, type Viewport } from "@itwin/core-frontend";
 import { type ViewData } from "@itwin/saved-views-client";
 interface CaptureSavedViewDataArgs {
-    /** Viewport to capture the view from. */
+    /** Viewport to capture. */
     viewport: Viewport;
-    /**
-     * Collect a list of models and categories that are currently not enabled in the {@linkcode viewport}.
-     * @default true
-     */
-    captureHiddenModelsAndCategories?: boolean | undefined;
 }
 export declare function captureSavedViewData(args: CaptureSavedViewDataArgs): Promise<ViewData>;
 export declare function getMissingModels(iModel: IModelConnection, knownModels: Set<string>): Promise<string[]>;

package/lib/captureSavedViewData.js

@@ -2,16 +2,11 @@ import { QueryRowFormat } from "@itwin/core-common";
 import { extractClipVectorsFromLegacy } from "./translation/clipVectorsLegacyExtractor.js";
 import { extractDisplayStyle2dFromLegacy, extractDisplayStyle3dFromLegacy, } from "./translation/displayStyleExtractor.js";
 export async function captureSavedViewData(args) {
-    const { captureHiddenModelsAndCategories = true } = args;
-    const hiddenCategoriesPromise = captureHiddenModelsAndCategories
-        ? getMissingCategories(args.viewport.iModel, new Set(args.viewport.view.categorySelector.toJSON().categories))
-        : undefined;
+    const hiddenCategoriesPromise = getMissingCategories(args.viewport.iModel, new Set(args.viewport.view.categorySelector.toJSON().categories));
     if (args.viewport.view.isSpatialView()) {
         const [hiddenCategories, hiddenModels] = await Promise.all([
             hiddenCategoriesPromise,
-            captureHiddenModelsAndCategories
-                ? getMissingModels(args.viewport.iModel, new Set(args.viewport.view.modelSelector.toJSON().models))
-                : undefined,
+            getMissingModels(args.viewport.iModel, new Set(args.viewport.view.modelSelector.toJSON().models)),
         ]);
         return createSpatialSavedViewObject(args.viewport, hiddenCategories, hiddenModels);
     }

package/lib/createViewState.d.ts

@@ -1,3 +1,16 @@
 import { type IModelConnection, type ViewState } from "@itwin/core-frontend";
-import { type SavedViewRepresentation } from "@itwin/saved-views-client";
-export declare function createViewState(iModel: IModelConnection, savedViewRsp: SavedViewRepresentation, useHiddenModelsAndCategories?: boolean): Promise<ViewState | undefined>;
+import { ViewData } from "@itwin/saved-views-client";
+export interface ViewStateCreateSettings {
+    /**
+     * Normally before {@link createViewState} function returns a {@link ViewState}, its {@linkcode ViewState.load} method
+     * is called and awaited. You may skip this step if you intend to perform it later.
+     * @default false
+     */
+    skipViewStateLoad?: boolean | undefined;
+    /**
+     * How to handle visibility of models and categories that exist in iModel but are not captured in Saved View data.
+     * @default "hidden"
+     */
+    modelAndCategoryVisibilityFallback?: "visible" | "hidden" | undefined;
+}
+export declare function createViewState(iModel: IModelConnection, savedViewData: ViewData, settings?: ViewStateCreateSettings): Promise<ViewState>;

package/lib/createViewState.js

@@ -8,22 +8,24 @@ import { isViewDataITwin3d, isViewDataITwinDrawing, isViewDataITwinSheet, } from
 import { getMissingCategories, getMissingModels } from "./captureSavedViewData.js";
 import { extractClipVectors } from "./translation/clipVectorsExtractor.js";
 import { extractDisplayStyle, extractDisplayStyle3d } from "./translation/displayStyleExtractor.js";
-export async function createViewState(iModel, savedViewRsp, useHiddenModelsAndCategories = true) {
-    const viewState = await createViewStateVariant(iModel, savedViewRsp);
-    if (useHiddenModelsAndCategories) {
-        await applyHiddenModelsAndCategories(iModel, viewState, savedViewRsp);
+export async function createViewState(iModel, savedViewData, settings = {}) {
+    const viewState = await createViewStateVariant(iModel, savedViewData);
+    if (settings.modelAndCategoryVisibilityFallback === "visible") {
+        await unhideNewModelsAndCategories(iModel, viewState, savedViewData);
+    }
+    if (!settings.skipViewStateLoad) {
+        await viewState.load();
     }
-    await viewState.load();
     return viewState;
 }
-async function createViewStateVariant(iModel, savedViewRsp) {
-    if (isViewDataITwinDrawing(savedViewRsp.savedViewData)) {
-        return createDrawingViewState(iModel, savedViewRsp.savedViewData.itwinDrawingView);
+async function createViewStateVariant(iModel, savedViewData) {
+    if (isViewDataITwinDrawing(savedViewData)) {
+        return createDrawingViewState(iModel, savedViewData.itwinDrawingView);
     }
-    if (isViewDataITwinSheet(savedViewRsp.savedViewData)) {
-        return createSheetViewState(iModel, savedViewRsp.savedViewData.itwinSheetView);
+    if (isViewDataITwinSheet(savedViewData)) {
+        return createSheetViewState(iModel, savedViewData.itwinSheetView);
     }
-    return createSpatialViewState(iModel, savedViewRsp.savedViewData.itwin3dView);
+    return createSpatialViewState(iModel, savedViewData.itwin3dView);
 }
 async function createSpatialViewState(iModel, viewData) {
     const seedViewState = await fetchIModelViewData(iModel, SpatialViewState.classFullName);
@@ -217,29 +219,29 @@ async function getDefaultViewIdFromClassName(iModel, viewClassName) {
 function cloneCode({ spec, scope, value }) {
     return { spec, scope, value };
 }
-async function applyHiddenModelsAndCategories(iModel, viewState, savedViewRsp) {
-    if (isViewDataITwin3d(savedViewRsp.savedViewData)) {
+async function unhideNewModelsAndCategories(iModel, viewState, savedViewData) {
+    if (isViewDataITwin3d(savedViewData)) {
         if (!viewState.isSpatialView()) {
             return;
         }
-        const savedViewData = savedViewRsp.savedViewData.itwin3dView;
-        if (!savedViewData.categories?.disabled || !savedViewData.models?.disabled) {
+        const viewData = savedViewData.itwin3dView;
+        if (!viewData.categories?.disabled || !viewData.models?.disabled) {
             return;
         }
         const [visibleCategories, visibleModels] = await Promise.all([
-            getMissingCategories(iModel, new Set(savedViewData.categories.disabled)),
-            getMissingModels(iModel, new Set(savedViewData.models.disabled)),
+            getMissingCategories(iModel, new Set(viewData.categories.disabled)),
+            getMissingModels(iModel, new Set(viewData.models.disabled)),
         ]);
         viewState.categorySelector.addCategories(visibleCategories);
         viewState.modelSelector.addModels(visibleModels);
         return;
     }
-    const savedViewData = isViewDataITwinDrawing(savedViewRsp.savedViewData)
-        ? savedViewRsp.savedViewData.itwinDrawingView
-        : savedViewRsp.savedViewData.itwinSheetView;
-    if (!savedViewData.categories?.disabled) {
+    const viewData = isViewDataITwinDrawing(savedViewData)
+        ? savedViewData.itwinDrawingView
+        : savedViewData.itwinSheetView;
+    if (!viewData.categories?.disabled) {
         return;
     }
-    const visibleCategories = await getMissingCategories(iModel, new Set(savedViewData.categories.disabled));
+    const visibleCategories = await getMissingCategories(iModel, new Set(viewData.categories.disabled));
     viewState.categorySelector.addCategories(visibleCategories);
 }

package/lib/experimental.d.ts

@@ -1,6 +1,3 @@
 export { createSavedViewOptions, type CreateSavedViewOptionsParams } from "./SavedViewTile/SavedViewOptions.js";
 export { SavedViewsExpandableBlockWidget } from "./SavedViewsWidget/SavedViewsExpandableBlockWidget.js";
 export { SavedViewsFolderWidget } from "./SavedViewsWidget/SavedViewsFolderWidget.js";
-export { applyExtensionsToViewport } from "./translation/SavedViewTranslation.js";
-export { createViewState } from "./createViewState.js";
-export { ModelCategoryOverrideProvider } from "./ModelCategoryOverrideProvider.js";

package/lib/experimental.js

@@ -5,6 +5,3 @@
 export { createSavedViewOptions } from "./SavedViewTile/SavedViewOptions.js";
 export { SavedViewsExpandableBlockWidget } from "./SavedViewsWidget/SavedViewsExpandableBlockWidget.js";
 export { SavedViewsFolderWidget } from "./SavedViewsWidget/SavedViewsFolderWidget.js";
-export { applyExtensionsToViewport } from "./translation/SavedViewTranslation.js";
-export { createViewState } from "./createViewState.js";
-export { ModelCategoryOverrideProvider } from "./ModelCategoryOverrideProvider.js";

package/lib/index.d.ts

@@ -8,7 +8,9 @@ export type { CreateGroupParams, CreateSavedViewParams, CreateTagParams, DeleteG
 export { SavedViewsContextProvider, type SavedViewsContext } from "./SavedViewsContext.js";
 export { StickyExpandableBlock } from "./StickyExpandableBlock/StickyExpandableBlock.js";
 export { TileGrid } from "./TileGrid/TileGrid.js";
+export { applySavedView, type ApplySavedViewSettings } from "./applySavedView.js";
 export { captureSavedViewData } from "./captureSavedViewData.js";
 export { captureSavedViewThumbnail } from "./captureSavedViewThumbnail.js";
+export { createViewState, type ViewStateCreateSettings } from "./createViewState.js";
 export { defaultLocalization, type LocalizationStrings } from "./localization.js";
 export { useSavedViews, type SavedViewActions } from "./useSavedViews.js";

package/lib/index.js

@@ -10,7 +10,9 @@ export { ITwinSavedViewsClient } from "./SavedViewsClient/ITwinSavedViewsClient.
 export { SavedViewsContextProvider } from "./SavedViewsContext.js";
 export { StickyExpandableBlock } from "./StickyExpandableBlock/StickyExpandableBlock.js";
 export { TileGrid } from "./TileGrid/TileGrid.js";
+export { applySavedView } from "./applySavedView.js";
 export { captureSavedViewData } from "./captureSavedViewData.js";
 export { captureSavedViewThumbnail } from "./captureSavedViewThumbnail.js";
+export { createViewState } from "./createViewState.js";
 export { defaultLocalization } from "./localization.js";
 export { useSavedViews } from "./useSavedViews.js";

package/lib/translation/SavedViewTypes.d.ts

@@ -1,7 +1,6 @@
 import type { Id64Array } from "@itwin/core-bentley";
 import type { CategorySelectorProps, DisplayStyle3dProps, DisplayStyleProps, EmphasizeElementsProps, ModelSelectorProps, SectionDrawingViewProps, SheetProps, SpatialViewDefinitionProps, ViewDefinition2dProps } from "@itwin/core-common";
 import type { Range3dProps } from "@itwin/core-geometry";
-import type { ModelCategoryOverrideProviderProps } from "../ModelCategoryOverrideProvider.js";
 export interface LegacySavedView3d extends LegacySavedViewBase {
     displayStyleProps: DisplayStyle3dProps;
     modelSelectorProps: ModelSelectorProps;
@@ -33,7 +32,6 @@ export interface LegacySavedViewBase {
     thumbnail?: string;
     categorySelectorProps: CategorySelectorProps;
     emphasizeElementsProps?: EmphasizeElementsProps;
-    visibilityOverrideProps?: ModelCategoryOverrideProviderProps;
     tags?: LegacyTag[];
     hiddenCategories?: Id64Array;
     extensions?: Map<string, string>;

package/lib/translation/SavedViewsExtensionHandlers.d.ts

@@ -1,13 +1,18 @@
 import { type Viewport } from "@itwin/core-frontend";
 export interface ExtensionHandler {
     extensionName: string;
-    onViewApply: (extensionData: string, vp: Viewport) => Promise<void>;
-}
-/**
- * Collection of default extension handlers
- */
-export declare class SavedViewsExtensionHandlers {
-    static EmphasizeElements: ExtensionHandler;
-    static PerModelCategoryVisibility: ExtensionHandler;
-    static VisibilityOverride: ExtensionHandler;
+    apply: (extensionData: string, viewport: Viewport) => void;
+    reset: (viewport: Viewport) => void;
 }
+export declare const extensionHandlers: {
+    emphasizeElements: {
+        extensionName: string;
+        apply: (extensionData: string, viewport: Viewport) => void;
+        reset: (viewport: Viewport) => void;
+    };
+    perModelCategoryVisibility: {
+        extensionName: string;
+        apply: (extensionData: string, viewport: Viewport) => void;
+        reset: (viewport: Viewport) => void;
+    };
+};

package/lib/translation/SavedViewsExtensionHandlers.js

@@ -1,42 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
 import { EmphasizeElements, PerModelCategoryVisibility } from "@itwin/core-frontend";
-import { ModelCategoryOverrideProvider } from "../ModelCategoryOverrideProvider.js";
-import { extractEmphasizeElements, extractPerModelCategoryVisibility, extractVisibilityOverride, } from "./extensionExtractor.js";
-/**
- * Collection of default extension handlers
- */
-export class SavedViewsExtensionHandlers {
-    static EmphasizeElements = {
+import { extractEmphasizeElements, extractPerModelCategoryVisibility } from "./extensionExtractor.js";
+export const extensionHandlers = {
+    emphasizeElements: {
         extensionName: "EmphasizeElements",
-        onViewApply: async (extensionData, vp) => {
+        apply: (extensionData, viewport) => {
             if (extensionData) {
                 const props = extractEmphasizeElements(extensionData);
                 if (props !== undefined) {
-                    EmphasizeElements.getOrCreate(vp).fromJSON(props, vp);
+                    EmphasizeElements.getOrCreate(viewport).fromJSON(props, viewport);
                 }
             }
         },
-    };
-    static PerModelCategoryVisibility = {
+        reset: (viewport) => {
+            if (EmphasizeElements.get(viewport)) {
+                EmphasizeElements.clear(viewport);
+                viewport.isFadeOutActive = false;
+            }
+        },
+    },
+    perModelCategoryVisibility: {
         extensionName: "PerModelCategoryVisibility",
-        onViewApply: async (extensionData, vp) => {
+        apply: (extensionData, viewport) => {
             const props = extractPerModelCategoryVisibility(extensionData) ?? [];
-            vp.perModelCategoryVisibility.clearOverrides();
             for (const override of props) {
-                vp.perModelCategoryVisibility.setOverride(override.modelId, override.categoryId, override.visible
+                viewport.perModelCategoryVisibility.setOverride(override.modelId, override.categoryId, override.visible
                     ? PerModelCategoryVisibility.Override.Show
                     : PerModelCategoryVisibility.Override.Hide);
             }
         },
-    };
-    static VisibilityOverride = {
-        extensionName: "VisibilityOverride",
-        onViewApply: async (extensionData, vp) => {
-            if (extensionData) {
-                const props = extractVisibilityOverride(extensionData);
-                if (props !== undefined) {
-                    ModelCategoryOverrideProvider.getOrCreate(vp).fromJSON(props);
-                }
-            }
+        reset: (viewport) => {
+            viewport.perModelCategoryVisibility.clearOverrides();
         },
-    };
-}
+    },
+};

package/lib/translation/extensionExtractor.d.ts

@@ -1,5 +1,4 @@
 import { type EmphasizeElementsProps } from "@itwin/core-common";
-import { ModelCategoryOverrideProviderProps } from "../ModelCategoryOverrideProvider.js";
 import type { PerModelCategoryVisibilityProps } from "./SavedViewTypes.js";
 /**
  * Extracts the EmphasizeElementsProps from string data in an extension
@@ -11,8 +10,3 @@ export declare const extractEmphasizeElements: (extensionData: string) => Emphas
  * @param extensionData
  */
 export declare const extractPerModelCategoryVisibility: (extensionData: string) => PerModelCategoryVisibilityProps[];
-/**
- * Extracts the VisibilityOverrideProps (ie ModelCategoryOverrideProviderProps) from string data in an extension
- * @param extensionData
- */
-export declare const extractVisibilityOverride: (extensionData: string) => ModelCategoryOverrideProviderProps | undefined;

package/lib/translation/extensionExtractor.js

@@ -6,11 +6,6 @@ const appearanceOverrideEmphElemMappings = [
     extractColor("color"),
     extractSimpleArray(simpleTypeOf("string"), "ids"),
 ];
-/** Appearance Override type for VisibilityOverrides (ie ModelCategoryOverrideProviderProps) */
-const appearanceOverrideVisibOvrMappings = [
-    extractSimpleArray(simpleTypeOf("string"), "ids"),
-    extractObject(featureAppearanceMappings, "app"),
-];
 const emphasizeElementsMapping = [
     extractSimpleArray(simpleTypeOf("string"), "neverDrawn"),
     extractSimpleArray(simpleTypeOf("string"), "alwaysDrawn"),
@@ -26,12 +21,6 @@ const perModelCategoryVisibilityMapping = [
     extractString("categoryId"),
     extractBoolean("visible"),
 ];
-const visibilityOverrideMapping = [
-    extractArray(appearanceOverrideVisibOvrMappings, "subCategoryOverrides"),
-    extractArray(appearanceOverrideVisibOvrMappings, "modelOverrides"),
-    extractObject(appearanceOverrideVisibOvrMappings, "catEmphasizeOverride"),
-    extractObject(appearanceOverrideVisibOvrMappings, "modelEmphasizeOverride"),
-];
 /**
  * Extracts the EmphasizeElementsProps from string data in an extension
  * @param extensionData
@@ -64,16 +53,3 @@ export const extractPerModelCategoryVisibility = (extensionData) => {
     }
     return outputArray;
 };
-/**
- * Extracts the VisibilityOverrideProps (ie ModelCategoryOverrideProviderProps) from string data in an extension
- * @param extensionData
- */
-export const extractVisibilityOverride = (extensionData) => {
-    const dataObj = JSON.parse(extensionData);
-    if (dataObj === undefined || dataObj.visibilityOverrideProps === undefined) {
-        return undefined;
-    }
-    const output = {};
-    applyExtraction(dataObj.visibilityOverrideProps, output, visibilityOverrideMapping);
-    return output;
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/saved-views-react",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/lib/ModelCategoryOverrideProvider.d.ts

@@ -1,31 +0,0 @@
-import { type FeatureAppearanceProps } from "@itwin/core-common";
-import type { FeatureOverrideProvider, FeatureSymbology, Viewport } from "@itwin/core-frontend";
-interface AppearanceOverrideProps {
-    ids: string[];
-    app: FeatureAppearanceProps;
-}
-/** Overrides given categories to provide emphasize functionality
- *  @public
- */
-export interface ModelCategoryOverrideProviderProps {
-    subCategoryOverrides?: AppearanceOverrideProps[];
-    modelOverrides?: AppearanceOverrideProps[];
-    catEmphasizeOverride?: AppearanceOverrideProps;
-    modelEmphasizeOverride?: AppearanceOverrideProps;
-}
-/** Model & Category override provider (override plus emphasize)
- *  @public
- */
-export declare class ModelCategoryOverrideProvider implements FeatureOverrideProvider {
-    private readonly _subCategoryOverrides;
-    private readonly _modelOverrides;
-    private readonly _emphasizedSubcats;
-    private readonly _emphasizedModels;
-    private _catDefaultAppearance?;
-    private _modelDefaultAppearance?;
-    static get(vp: Viewport): ModelCategoryOverrideProvider | undefined;
-    static getOrCreate(vp: Viewport): ModelCategoryOverrideProvider;
-    addFeatureOverrides(overrides: FeatureSymbology.Overrides, _vp: Viewport): void;
-    fromJSON(props: ModelCategoryOverrideProviderProps): boolean;
-}
-export {};

package/lib/ModelCategoryOverrideProvider.js

@@ -1,88 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { FeatureAppearance } from "@itwin/core-common";
-/** Model & Category override provider (override plus emphasize)
- *  @public
- */
-export class ModelCategoryOverrideProvider {
-    _subCategoryOverrides = new Map();
-    _modelOverrides = new Map();
-    _emphasizedSubcats = [];
-    _emphasizedModels = [];
-    _catDefaultAppearance;
-    _modelDefaultAppearance;
-    static get(vp) {
-        return vp.findFeatureOverrideProviderOfType(ModelCategoryOverrideProvider);
-    }
-    static getOrCreate(vp) {
-        let provider = this.get(vp);
-        if (!provider) {
-            provider = new ModelCategoryOverrideProvider();
-            vp.addFeatureOverrideProvider(provider);
-        }
-        return provider;
-    }
-    addFeatureOverrides(overrides, _vp) {
-        this._subCategoryOverrides.forEach((appearance, ids, _map) => {
-            ids.forEach((id) => {
-                overrides.override({ subCategoryId: id, appearance });
-            });
-        });
-        this._modelOverrides.forEach((appearance, ids, _map) => {
-            ids.forEach((id) => {
-                overrides.override({ modelId: id, appearance });
-            });
-        });
-        if (0 !== this._emphasizedSubcats.length) {
-            if (this._catDefaultAppearance) {
-                overrides.setDefaultOverrides(this._catDefaultAppearance, true);
-            }
-            // Override with nothing so that we keep the category looking normal and override the default appearance of everything else
-            const override = FeatureAppearance.fromJSON({});
-            this._emphasizedSubcats.forEach((id) => {
-                overrides.override({
-                    subCategoryId: id,
-                    appearance: override,
-                    onConflict: "replace",
-                });
-            });
-        }
-        if (0 !== this._emphasizedModels.length) {
-            if (this._modelDefaultAppearance) {
-                overrides.setDefaultOverrides(this._modelDefaultAppearance, true);
-            }
-            // Override with nothing so that we keep the category looking normal and override the default appearance of everything else
-            const override = FeatureAppearance.fromJSON({});
-            this._emphasizedModels.forEach((id) => {
-                overrides.override({
-                    modelId: id,
-                    appearance: override,
-                    onConflict: "replace",
-                });
-            });
-        }
-    }
-    fromJSON(props) {
-        if (props.subCategoryOverrides) {
-            props.subCategoryOverrides.forEach((appProps) => {
-                this._subCategoryOverrides.set(appProps.ids, FeatureAppearance.fromJSON(appProps.app));
-            });
-        }
-        if (props.modelOverrides) {
-            props.modelOverrides.forEach((appProps) => {
-                this._modelOverrides.set(appProps.ids, FeatureAppearance.fromJSON(appProps.app));
-            });
-        }
-        if (props.catEmphasizeOverride) {
-            this._emphasizedSubcats.push(...props.catEmphasizeOverride.ids);
-            this._catDefaultAppearance = FeatureAppearance.fromJSON(props.catEmphasizeOverride.app);
-        }
-        if (props.modelEmphasizeOverride) {
-            this._emphasizedModels.push(...props.modelEmphasizeOverride.ids);
-            this._modelDefaultAppearance = FeatureAppearance.fromJSON(props.modelEmphasizeOverride.app);
-        }
-        return true;
-    }
-}

package/lib/translation/SavedViewTranslation.d.ts

@@ -1,4 +0,0 @@
-import { type Viewport } from "@itwin/core-frontend";
-import type { SavedView } from "../SavedView.js";
-/** Apply extension data (overrides) onto the supplied viewport. Only works with legacy-formatted extension data. */
-export declare function applyExtensionsToViewport(viewport: Viewport, savedView: SavedView): Promise<void>;

package/lib/translation/SavedViewTranslation.js

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { EmphasizeElements } from "@itwin/core-frontend";
-import { SavedViewsExtensionHandlers } from "./SavedViewsExtensionHandlers.js";
-/** Apply extension data (overrides) onto the supplied viewport. Only works with legacy-formatted extension data. */
-export async function applyExtensionsToViewport(viewport, savedView) {
-    // Clear the current if there's any (this should always happen, even if there are no extensions)
-    if (EmphasizeElements.get(viewport)) {
-        EmphasizeElements.clear(viewport);
-        viewport.isFadeOutActive = false;
-    }
-    const defaultHandlers = [
-        SavedViewsExtensionHandlers.EmphasizeElements,
-        SavedViewsExtensionHandlers.PerModelCategoryVisibility,
-        SavedViewsExtensionHandlers.VisibilityOverride,
-    ];
-    for (const extHandler of defaultHandlers) {
-        const extData = savedView.extensions?.get(extHandler.extensionName);
-        if (extData) {
-            await extHandler.onViewApply(extData, viewport);
-        }
-    }
-}