@cognite/reveal-components 1.0.2 → 1.48535.0

package/dist/data-providers/network/cad/fetchHybridAssetMappingsForModels.js

@@ -1,44 +1,47 @@
-import { isDefined as e } from "../../../utilities/isDefined.js";
-import { convertToHybridAssetMapping as t } from "../../cache/cad/rawAssetMappingTypes.js";
-import { isSameModel as n } from "../../../utilities/isSameModel.js";
-import { chunk as r } from "lodash-es";
-//#region libs/shared/reveal-components/src/data-providers/network/cad/fetchHybridAssetMappingsForModels.ts
-var i = 10;
-async function a(e, t, n, a, c) {
-	let l = a === void 0, u = [];
-	for (let o of r(t, i)) {
-		let t = o.map(async (t) => await s(e, t, a, l, n, c)), r = await Promise.all(t);
-		u.push(...r);
-	}
-	return {
-		items: u,
-		nextCursors: o(u)
-	};
+import { chunk } from "lodash-es";
+import { isSameModel } from "../../../utilities/isSameModel.js";
+import { isDmCadAssetMapping, isClassicCadAssetMapping } from "../../cache/cad/assetMappingTypes.js";
+const MODEL_CHUNK_SIZE = 10;
+export async function fetchHybridAssetMappingsForModels(dataType, models, cursorsForModels, cache) {
+    const firstPage = cursorsForModels === undefined;
+    const currentPagesOfAssetMappings = [];
+    for (const modelChunk of chunk(models, MODEL_CHUNK_SIZE)){
+        const modelChunkAssetMappingPromises = modelChunk.map(async (model)=>await fetchAssetMappingsForModel(dataType, model, cursorsForModels, firstPage, cache));
+        const modelChunkAssetMappings = await Promise.all(modelChunkAssetMappingPromises);
+        currentPagesOfAssetMappings.push(...modelChunkAssetMappings);
+    }
+    return {
+        items: currentPagesOfAssetMappings,
+        nextCursors: getNextCursors(currentPagesOfAssetMappings)
+    };
 }
-function o(e) {
-	return e.map(({ mappings: e, model: t }) => ({
-		cursor: e.nextCursor,
-		model: t
-	})).filter((e) => e.cursor !== void 0);
+function getNextCursors(lastPage) {
+    return lastPage.map(({ mappings, model })=>({
+            cursor: mappings.nextCursor,
+            model
+        })).filter((mappingModel)=>mappingModel.cursor !== undefined);
 }
-async function s(r, i, a, o, s, c) {
-	let l = a?.find((e) => n(e.model, i))?.cursor;
-	if (!o && l === void 0) return {
-		mappings: { items: [] },
-		model: i
-	};
-	let u = await c.assetMappings3D.list(i.modelId, i.revisionId, {
-		cursor: l,
-		limit: s,
-		getDmsInstances: r === "dm"
-	});
-	return {
-		mappings: {
-			items: u.items.flatMap(t).filter(e),
-			nextCursor: u.nextCursor
-		},
-		model: i
-	};
+function isMappingOfType(dataType, mapping) {
+    return dataType === 'dm' ? isDmCadAssetMapping(mapping) : isClassicCadAssetMapping(mapping);
 }
-//#endregion
-export { a as fetchHybridAssetMappingsForModels };
+async function fetchAssetMappingsForModel(dataType, model, cursorsForModels, isFirstPage, cache) {
+    const cursorForModel = cursorsForModels?.find((nextCursor)=>isSameModel(nextCursor.model, model))?.cursor;
+    if (!isFirstPage && cursorForModel === undefined) {
+        return {
+            mappings: {
+                items: []
+            },
+            model
+        };
+    }
+    const { mappings, nextCursor } = await cache.getAssetMappingsForModelPage(model.modelId, model.revisionId, cursorForModel, dataType === 'dm');
+    return {
+        mappings: {
+            items: mappings.filter((mapping)=>isMappingOfType(dataType, mapping)),
+            nextCursor
+        },
+        model
+    };
+}
+
+//# sourceMappingURL=fetchHybridAssetMappingsForModels.js.map

package/dist/data-providers/network/cad/fetchHybridAssetMappingsForModels.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/data-providers/network/cad/fetchHybridAssetMappingsForModels.ts"],"sourcesContent":["import { chunk } from 'lodash-es';\n\nimport { type ListResponse } from '@cognite/sdk';\n\nimport { isSameModel } from '../../../utilities/isSameModel';\nimport {\n  type ClassicCadAssetMapping,\n  type DmCadAssetMapping,\n  type HybridCadAssetMapping,\n  isDmCadAssetMapping,\n  isClassicCadAssetMapping,\n} from '../../cache/cad/assetMappingTypes';\nimport { type ClassicCadAssetMappingCache } from '../../cache/cad/ClassicCadAssetMappingCache';\nimport {\n  type RawCdfHybridClassicCadAssetMapping,\n  type RawCdfHybridDmCadAssetMapping,\n} from '../../cache/cad/rawAssetMappingTypes';\nimport { type ModelRevisionId } from '../../cache/types';\n\nimport type { CursorForModel } from './types';\n\nconst MODEL_CHUNK_SIZE = 10;\n\nexport type HybridDataType = 'dm' | 'classic';\n\nexport type RawHybridAssetMapping<T extends HybridDataType = HybridDataType> =\n  T extends 'dm'\n    ? RawCdfHybridDmCadAssetMapping\n    : RawCdfHybridClassicCadAssetMapping;\n\nexport type HybridAssetMapping<T extends HybridDataType> = T extends 'dm'\n  ? DmCadAssetMapping\n  : ClassicCadAssetMapping;\n\nexport type HybridAssetMappingsWithModel<T extends HybridDataType> = {\n  mappings: ListResponse<Array<HybridAssetMapping<T>>>;\n  model: ModelRevisionId;\n};\n\nexport type HybridMappingsPerModelWithCursors<T extends HybridDataType> = {\n  items: Array<HybridAssetMappingsWithModel<T>>;\n  nextCursors: CursorForModel[];\n};\n\nexport async function fetchHybridAssetMappingsForModels<\n  T extends HybridDataType,\n>(\n  dataType: T,\n  models: ModelRevisionId[],\n  cursorsForModels: CursorForModel[] | undefined,\n  cache: ClassicCadAssetMappingCache\n): Promise<HybridMappingsPerModelWithCursors<T>> {\n  const firstPage = cursorsForModels === undefined;\n\n  const currentPagesOfAssetMappings: Array<HybridAssetMappingsWithModel<T>> =\n    [];\n\n  for (const modelChunk of chunk(models, MODEL_CHUNK_SIZE)) {\n    const modelChunkAssetMappingPromises = modelChunk.map(\n      async (model) =>\n        await fetchAssetMappingsForModel(\n          dataType,\n          model,\n          cursorsForModels,\n          firstPage,\n          cache\n        )\n    );\n\n    const modelChunkAssetMappings = await Promise.all(\n      modelChunkAssetMappingPromises\n    );\n\n    currentPagesOfAssetMappings.push(...modelChunkAssetMappings);\n  }\n\n  return {\n    items: currentPagesOfAssetMappings,\n    nextCursors: getNextCursors(currentPagesOfAssetMappings),\n  };\n}\n\nfunction getNextCursors<T extends HybridDataType>(\n  lastPage: Array<HybridAssetMappingsWithModel<T>>\n): CursorForModel[] {\n  return lastPage\n    .map(({ mappings, model }) => ({ cursor: mappings.nextCursor, model }))\n    .filter((mappingModel) => mappingModel.cursor !== undefined);\n}\n\nfunction isMappingOfType<T extends HybridDataType>(\n  dataType: T,\n  mapping: HybridCadAssetMapping\n): mapping is HybridAssetMapping<T> {\n  return dataType === 'dm'\n    ? isDmCadAssetMapping(mapping)\n    : isClassicCadAssetMapping(mapping);\n}\n\nasync function fetchAssetMappingsForModel<T extends HybridDataType>(\n  dataType: T,\n  model: ModelRevisionId,\n  cursorsForModels: CursorForModel[] | undefined,\n  isFirstPage: boolean,\n  cache: ClassicCadAssetMappingCache\n): Promise<HybridAssetMappingsWithModel<T>> {\n  const cursorForModel = cursorsForModels?.find((nextCursor) =>\n    isSameModel(nextCursor.model, model)\n  )?.cursor;\n\n  if (!isFirstPage && cursorForModel === undefined) {\n    return { mappings: { items: [] }, model };\n  }\n\n  const { mappings, nextCursor } = await cache.getAssetMappingsForModelPage(\n    model.modelId,\n    model.revisionId,\n    cursorForModel,\n    dataType === 'dm'\n  );\n\n  return {\n    mappings: {\n      items: mappings.filter((mapping) => isMappingOfType(dataType, mapping)),\n      nextCursor,\n    },\n    model,\n  };\n}\n"],"names":["chunk","isSameModel","isDmCadAssetMapping","isClassicCadAssetMapping","MODEL_CHUNK_SIZE","fetchHybridAssetMappingsForModels","dataType","models","cursorsForModels","cache","firstPage","undefined","currentPagesOfAssetMappings","modelChunk","modelChunkAssetMappingPromises","map","model","fetchAssetMappingsForModel","modelChunkAssetMappings","Promise","all","push","items","nextCursors","getNextCursors","lastPage","mappings","cursor","nextCursor","filter","mappingModel","isMappingOfType","mapping","isFirstPage","cursorForModel","find","getAssetMappingsForModelPage","modelId","revisionId"],"mappings":"AAAA,SAASA,KAAK,QAAQ,YAAY;AAIlC,SAASC,WAAW,QAAQ,oCAAiC;AAC7D,SAIEC,mBAAmB,EACnBC,wBAAwB,QACnB,uCAAoC;AAU3C,MAAMC,mBAAmB;AAuBzB,OAAO,eAAeC,kCAGpBC,QAAW,EACXC,MAAyB,EACzBC,gBAA8C,EAC9CC,KAAkC;IAElC,MAAMC,YAAYF,qBAAqBG;IAEvC,MAAMC,8BACJ,EAAE;IAEJ,KAAK,MAAMC,cAAcb,MAAMO,QAAQH,kBAAmB;QACxD,MAAMU,iCAAiCD,WAAWE,GAAG,CACnD,OAAOC,QACL,MAAMC,2BACJX,UACAU,OACAR,kBACAE,WACAD;QAIN,MAAMS,0BAA0B,MAAMC,QAAQC,GAAG,CAC/CN;QAGFF,4BAA4BS,IAAI,IAAIH;IACtC;IAEA,OAAO;QACLI,OAAOV;QACPW,aAAaC,eAAeZ;IAC9B;AACF;AAEA,SAASY,eACPC,QAAgD;IAEhD,OAAOA,SACJV,GAAG,CAAC,CAAC,EAAEW,QAAQ,EAAEV,KAAK,EAAE,GAAM,CAAA;YAAEW,QAAQD,SAASE,UAAU;YAAEZ;QAAM,CAAA,GACnEa,MAAM,CAAC,CAACC,eAAiBA,aAAaH,MAAM,KAAKhB;AACtD;AAEA,SAASoB,gBACPzB,QAAW,EACX0B,OAA8B;IAE9B,OAAO1B,aAAa,OAChBJ,oBAAoB8B,WACpB7B,yBAAyB6B;AAC/B;AAEA,eAAef,2BACbX,QAAW,EACXU,KAAsB,EACtBR,gBAA8C,EAC9CyB,WAAoB,EACpBxB,KAAkC;IAElC,MAAMyB,iBAAiB1B,kBAAkB2B,KAAK,CAACP,aAC7C3B,YAAY2B,WAAWZ,KAAK,EAAEA,SAC7BW;IAEH,IAAI,CAACM,eAAeC,mBAAmBvB,WAAW;QAChD,OAAO;YAAEe,UAAU;gBAAEJ,OAAO,EAAE;YAAC;YAAGN;QAAM;IAC1C;IAEA,MAAM,EAAEU,QAAQ,EAAEE,UAAU,EAAE,GAAG,MAAMnB,MAAM2B,4BAA4B,CACvEpB,MAAMqB,OAAO,EACbrB,MAAMsB,UAAU,EAChBJ,gBACA5B,aAAa;IAGf,OAAO;QACLoB,UAAU;YACRJ,OAAOI,SAASG,MAAM,CAAC,CAACG,UAAYD,gBAAgBzB,UAAU0B;YAC9DJ;QACF;QACAZ;IACF;AACF"}

package/dist/data-providers/network/cad/getAssetsFromAssetMappings.d.ts

@@ -1,8 +1,8 @@
-import { AddModelOptions } from '@cognite/reveal';
-import { CogniteClient, ListResponse } from '@cognite/sdk';
-import { ClassicCadModelMappingsWithAssets } from '../../../ui/query/useSearchMappedEquipmentAssetMappings';
-import { ClassicCadAssetMapping } from '../../cache/cad/assetMappingTypes';
+import { type AddModelOptions } from "@cognite/reveal";
+import { type CogniteClient, type ListResponse } from "@cognite/sdk";
+import { type ClassicCadModelMappingsWithAssets } from "../../../ui/query/useSearchMappedEquipmentAssetMappings";
+import { type ClassicCadAssetMapping } from "../../cache/cad/assetMappingTypes";
 export declare function getAssetsFromAssetMappings(sdk: CogniteClient, modelsMappings: Array<{
-    model: AddModelOptions;
-    mappings: ListResponse<ClassicCadAssetMapping[]>;
+	model: AddModelOptions;
+	mappings: ListResponse<ClassicCadAssetMapping[]>;
 }>): Promise<ClassicCadModelMappingsWithAssets[]>;

package/dist/data-providers/network/cad/getAssetsFromAssetMappings.js

@@ -1,25 +1,32 @@
-import { chunk as e } from "lodash-es";
-//#region libs/shared/reveal-components/src/data-providers/network/cad/getAssetsFromAssetMappings.ts
-var t = 10;
-async function n(n, r) {
-	let i = [];
-	for (let a of e(r, t)) {
-		let e = a.map(async ({ mappings: e, model: t }) => {
-			if (e.items.length === 0) return {
-				model: t,
-				assets: [],
-				mappings: e
-			};
-			let r = Array.from(new Set(e.items.map((e) => e.assetId))).map((e) => ({ id: e }));
-			return {
-				model: t,
-				assets: await n.assets.retrieve(r, { ignoreUnknownIds: !0 }),
-				mappings: e
-			};
-		});
-		i.push(...await Promise.all(e));
-	}
-	return i;
+import { chunk } from "lodash-es";
+const MODELS_MAPPING_CHUNK_SIZE = 10;
+export async function getAssetsFromAssetMappings(sdk, modelsMappings) {
+    const mappingsWithAssets = [];
+    for (const modelsMappingsChunk of chunk(modelsMappings, MODELS_MAPPING_CHUNK_SIZE)){
+        const mappingsWithAssetsPromises = modelsMappingsChunk.map(async ({ mappings, model })=>{
+            if (mappings.items.length === 0) {
+                return {
+                    model,
+                    assets: [],
+                    mappings
+                };
+            }
+            const deduplicatedAssetIds = Array.from(new Set(mappings.items.map((mapping)=>mapping.assetId)));
+            const assetIdObjects = deduplicatedAssetIds.map((id)=>({
+                    id
+                }));
+            const assets = await sdk.assets.retrieve(assetIdObjects, {
+                ignoreUnknownIds: true
+            });
+            return {
+                model,
+                assets,
+                mappings
+            };
+        });
+        mappingsWithAssets.push(...await Promise.all(mappingsWithAssetsPromises));
+    }
+    return mappingsWithAssets;
 }
-//#endregion
-export { n as getAssetsFromAssetMappings };
+
+//# sourceMappingURL=getAssetsFromAssetMappings.js.map

package/dist/data-providers/network/cad/getAssetsFromAssetMappings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/data-providers/network/cad/getAssetsFromAssetMappings.ts"],"sourcesContent":["import { chunk } from 'lodash-es';\n\nimport { type AddModelOptions } from '@cognite/reveal';\nimport { type CogniteClient, type ListResponse } from '@cognite/sdk';\n\nimport { type ClassicCadModelMappingsWithAssets } from '../../../ui/query/useSearchMappedEquipmentAssetMappings';\nimport { type ClassicCadAssetMapping } from '../../cache/cad/assetMappingTypes';\n\nconst MODELS_MAPPING_CHUNK_SIZE = 10;\n\nexport async function getAssetsFromAssetMappings(\n  sdk: CogniteClient,\n  modelsMappings: Array<{\n    model: AddModelOptions;\n    mappings: ListResponse<ClassicCadAssetMapping[]>;\n  }>\n): Promise<ClassicCadModelMappingsWithAssets[]> {\n  const mappingsWithAssets: ClassicCadModelMappingsWithAssets[] = [];\n\n  for (const modelsMappingsChunk of chunk(\n    modelsMappings,\n    MODELS_MAPPING_CHUNK_SIZE\n  )) {\n    const mappingsWithAssetsPromises = modelsMappingsChunk.map(\n      async ({ mappings, model }) => {\n        if (mappings.items.length === 0) {\n          return { model, assets: [], mappings };\n        }\n\n        const deduplicatedAssetIds = Array.from(\n          new Set(mappings.items.map((mapping) => mapping.assetId))\n        );\n        const assetIdObjects = deduplicatedAssetIds.map((id) => ({ id }));\n\n        const assets = await sdk.assets.retrieve(assetIdObjects, {\n          ignoreUnknownIds: true,\n        });\n\n        return { model, assets, mappings };\n      }\n    );\n\n    mappingsWithAssets.push(...(await Promise.all(mappingsWithAssetsPromises)));\n  }\n\n  return mappingsWithAssets;\n}\n"],"names":["chunk","MODELS_MAPPING_CHUNK_SIZE","getAssetsFromAssetMappings","sdk","modelsMappings","mappingsWithAssets","modelsMappingsChunk","mappingsWithAssetsPromises","map","mappings","model","items","length","assets","deduplicatedAssetIds","Array","from","Set","mapping","assetId","assetIdObjects","id","retrieve","ignoreUnknownIds","push","Promise","all"],"mappings":"AAAA,SAASA,KAAK,QAAQ,YAAY;AAQlC,MAAMC,4BAA4B;AAElC,OAAO,eAAeC,2BACpBC,GAAkB,EAClBC,cAGE;IAEF,MAAMC,qBAA0D,EAAE;IAElE,KAAK,MAAMC,uBAAuBN,MAChCI,gBACAH,2BACC;QACD,MAAMM,6BAA6BD,oBAAoBE,GAAG,CACxD,OAAO,EAAEC,QAAQ,EAAEC,KAAK,EAAE;YACxB,IAAID,SAASE,KAAK,CAACC,MAAM,KAAK,GAAG;gBAC/B,OAAO;oBAAEF;oBAAOG,QAAQ,EAAE;oBAAEJ;gBAAS;YACvC;YAEA,MAAMK,uBAAuBC,MAAMC,IAAI,CACrC,IAAIC,IAAIR,SAASE,KAAK,CAACH,GAAG,CAAC,CAACU,UAAYA,QAAQC,OAAO;YAEzD,MAAMC,iBAAiBN,qBAAqBN,GAAG,CAAC,CAACa,KAAQ,CAAA;oBAAEA;gBAAG,CAAA;YAE9D,MAAMR,SAAS,MAAMV,IAAIU,MAAM,CAACS,QAAQ,CAACF,gBAAgB;gBACvDG,kBAAkB;YACpB;YAEA,OAAO;gBAAEb;gBAAOG;gBAAQJ;YAAS;QACnC;QAGFJ,mBAAmBmB,IAAI,IAAK,MAAMC,QAAQC,GAAG,CAACnB;IAChD;IAEA,OAAOF;AACT"}

package/dist/data-providers/network/cad/searchClassicAssetsForCadModels.d.ts

@@ -1,11 +1,13 @@
-import { CogniteClient } from '@cognite/sdk';
-import { ClassicCadAssetMappingCache } from '../../cache/cad/ClassicCadAssetMappingCache';
-import { Classic3DResourceIdentifier } from '../../types/resources';
-import { AllAssetFilterProps } from '../common/filters';
-import { fetchAssetPage } from './fetchAllAssetsForCadModels';
-import { SearchClassicCadAssetsResponse } from './types';
+import type { Asset, CogniteClient } from "@cognite/sdk";
+import { type ClassicCadAssetMappingCache } from "../../cache/cad/ClassicCadAssetMappingCache";
+import type { Classic3DResourceIdentifier } from "../../types/resources";
+import { type AllAssetFilterProps } from "../common/filters";
+import type { AssetResultMap } from "../types";
+import { fetchAssetPage } from "./fetchAllAssetsForCadModels";
+import type { SearchClassicCadAssetsResponse } from "./types";
 type SearchClassicAssetsForCadModelsDependencies = {
-    fetchAssetPage: typeof fetchAssetPage;
+	fetchAssetPage: typeof fetchAssetPage;
 };
 export declare function searchClassicAssetsForCadModels(models: Classic3DResourceIdentifier[], limit: number, cursor: string | undefined, filters: AllAssetFilterProps | undefined, sdk: CogniteClient, assetMappingAndNode3dCache: ClassicCadAssetMappingCache, dependencies?: SearchClassicAssetsForCadModelsDependencies): Promise<SearchClassicCadAssetsResponse>;
+export declare function filterClassicAssetsOnCadAssetMappings(cadModels: Classic3DResourceIdentifier[], assetsToScanFrom: Asset[], cache: ClassicCadAssetMappingCache): Promise<AssetResultMap>;
 export {};

package/dist/data-providers/network/cad/searchClassicAssetsForCadModels.js

@@ -1,132 +1,239 @@
-import { createModelRevisionKey as e } from "../../cache/idAndKeyTranslation.js";
-import { isDefined as t } from "../../../utilities/isDefined.js";
-import { executeParallel as n } from "../../../utilities/executeParallel.js";
-import { isClassicCadAssetMapping as r } from "../../cache/cad/assetMappingTypes.js";
-import { fetchAssetPage as i } from "./fetchAllAssetsForCadModels.js";
-//#region libs/shared/reveal-components/src/data-providers/network/cad/searchClassicAssetsForCadModels.ts
-var a = 4, o = 10, s = 20;
-async function c(e, t, n, r, a, c, u = { fetchAssetPage: i }) {
-	if (e.length === 0) return {
-		data: [],
-		nextCursor: void 0
-	};
-	let f = await d(e, r, n, a);
-	return f.strategy === "scanFromAssetMappings" ? l(e, t, f, r, a, c, u.fetchAssetPage, o, s) : h(e, t, f, r, a, c, s);
+import { executeParallel } from "../../../utilities/executeParallel.js";
+import { isDefined } from "../../../utilities/isDefined.js";
+import { isClassicCadAssetMapping } from "../../cache/cad/assetMappingTypes.js";
+import { createModelRevisionKey } from "../../cache/idAndKeyTranslation.js";
+import { fetchAssetPage } from "./fetchAllAssetsForCadModels.js";
+// MAX_PARALLEL_QUERIES defines how many parallel requests we do when fetching
+// assetIds per model and when fetching the count of mapped assets vs filtered
+// assets for strategy selection.
+const MAX_PARALLEL_QUERIES = 4;
+// MIN_ITEMS_PER_PAGE defines the minimum number of items to fetch per page
+// when using the 'scanFromAssetMappings' strategy. This is to ensure we get
+// a reasonable amount of data per page.
+const MIN_ITEMS_PER_PAGE = 10;
+// MAX_MAPPING_REQUESTS_PER_PAGE defines the maximum number of requests to make
+// to the asset mapping endpoint per page. This is a safeguard to prevent too
+// many requests in cases where there are many models or many mapped assets.
+// When it is reached, we will return whatever data we have collected so far,
+// along with a cursor that will allow the next page to continue where we left off.
+const MAX_MAPPING_REQUESTS_PER_PAGE = 20;
+export async function searchClassicAssetsForCadModels(models, limit, cursor, filters, sdk, assetMappingAndNode3dCache, dependencies = {
+    fetchAssetPage
+}) {
+    if (models.length === 0) {
+        return {
+            data: [],
+            nextCursor: undefined
+        };
+    }
+    const parsedCursor = await getCursorForStrategy(models, filters, cursor, sdk);
+    if (parsedCursor.strategy === 'scanFromAssetMappings') {
+        return searchScanFromMappings(models, limit, parsedCursor.cursors, filters, sdk, assetMappingAndNode3dCache, dependencies.fetchAssetPage, MIN_ITEMS_PER_PAGE, MAX_MAPPING_REQUESTS_PER_PAGE);
+    }
+    return scanFromAssetsFilteredOnAssetMappings(models, limit, parsedCursor ?? {
+        assetCursor: undefined,
+        mappingCursor: undefined
+    }, filters, sdk, assetMappingAndNode3dCache);
 }
-async function l(e, t, n, r, i, a, o, s = 10, c = 20) {
-	let { assetCursor: l, mappingCursor: d } = n.cursors, f = [], p = /* @__PURE__ */ new Set(), m = 0, h, g;
-	for (; f.length < s && m < c;) {
-		if (!h || !l) {
-			let { assetIds: t, modelKeyWithCursors: n } = await u(e, a, d);
-			h = t, g = n;
-		}
-		if (h.length === 0) break;
-		let { data: n, nextCursor: s } = await o({
-			assetIds: h,
-			filters: r,
-			cursor: l,
-			limit: t,
-			sdk: i,
-			maxRequestsPerPage: c
-		});
-		if (n.forEach((e) => {
-			p.has(e.id) || (p.add(e.id), f.push(e));
-		}), m++, l = s, !l && (d = g, h = void 0, !d)) break;
-	}
-	return {
-		data: f,
-		nextCursor: l || d ? JSON.stringify({
-			strategy: n.strategy,
-			cursors: {
-				assetCursor: l,
-				mappingCursor: d
-			}
-		}) : void 0
-	};
+async function searchScanFromMappings(models, limit, cursor, filters, sdk, cache, fetchAssets, minItemsPerPage = MIN_ITEMS_PER_PAGE, maxMappingRequestsPerPage = MAX_MAPPING_REQUESTS_PER_PAGE) {
+    let { assetCursor, mappingCursor } = cursor;
+    const collectedData = [];
+    const seenIds = new Set();
+    let iterations = 0;
+    let currentBatch = undefined;
+    let nextMappingCursor = undefined;
+    // Loop until we find enough data or hit the iteration limit
+    while(collectedData.length < minItemsPerPage && iterations < maxMappingRequestsPerPage){
+        // 1. Fetch new IDs only if we aren't currently resuming a chunked batch
+        if (!currentBatch || !assetCursor) {
+            const { assetIds, modelKeyWithCursors } = await getMappedAssetIdsPageResultPerRevision(models, cache, mappingCursor);
+            currentBatch = assetIds;
+            // We don't advance mappingCursor yet, we only do that when currentBatch is fully processed
+            nextMappingCursor = modelKeyWithCursors;
+        }
+        if (currentBatch.length === 0) break;
+        // 2. Fetch Assets for this batch
+        const { items, nextCursor: newAssetCursor } = await fetchAssets({
+            assetIds: currentBatch,
+            filters,
+            cursor: assetCursor,
+            limit,
+            sdk,
+            maxRequestsPerPage: maxMappingRequestsPerPage
+        });
+        // 3. Collect & Deduplicate
+        items.forEach((a)=>{
+            if (!seenIds.has(a.id)) {
+                seenIds.add(a.id);
+                collectedData.push(a);
+            }
+        });
+        iterations++;
+        assetCursor = newAssetCursor;
+        // 4. Batch Exhaustion Logic: If this chunk fetch finished the batch, advance the mapping cursor
+        if (!assetCursor) {
+            mappingCursor = nextMappingCursor;
+            currentBatch = undefined; // Signal next loop to fetch fresh IDs
+            if (!mappingCursor) break; // End of the line
+        }
+    }
+    // Final Cursor Serialization
+    const nextCursor = assetCursor || mappingCursor ? {
+        strategy: 'scanFromAssetMappings',
+        cursors: {
+            assetCursor,
+            mappingCursor
+        }
+    } : undefined;
+    return {
+        data: collectedData,
+        nextCursor: JSON.stringify(nextCursor)
+    };
 }
-async function u(i, o, s) {
-	let c = (await n(i.map((t) => async () => {
-		let n = e(t.modelId, t.revisionId), r = s?.find((e) => e.modelRevisionKey === n);
-		if (s !== void 0 && r === void 0) return;
-		let { mappings: i, nextCursor: a } = await o.getAssetMappingsForModelPage(t.modelId, t.revisionId, r?.cursor);
-		return {
-			mappings: i,
-			nextCursorEntry: a === void 0 ? void 0 : {
-				modelRevisionKey: n,
-				cursor: a
-			}
-		};
-	}), a)).filter(t), l = c.map((e) => e.nextCursorEntry).filter(t);
-	return {
-		assetIds: c.flatMap((e) => e.mappings.filter(r).map((e) => e.assetId)),
-		modelKeyWithCursors: l.length > 0 ? l : void 0
-	};
+async function getMappedAssetIdsPageResultPerRevision(models, assetMappingAndNode3dCache, assetMappingCursors) {
+    const results = await executeParallel(models.map((model)=>async ()=>{
+            const modelRevisionKey = createModelRevisionKey(model.modelId, model.revisionId);
+            const cursor = assetMappingCursors?.find((c)=>c.modelRevisionKey === modelRevisionKey);
+            if (assetMappingCursors !== undefined && cursor === undefined) {
+                return undefined;
+            }
+            const { mappings, nextCursor } = await assetMappingAndNode3dCache.getAssetMappingsForModelPage(model.modelId, model.revisionId, cursor?.cursor);
+            const nextCursorEntry = nextCursor !== undefined ? {
+                modelRevisionKey,
+                cursor: nextCursor
+            } : undefined;
+            return {
+                mappings,
+                nextCursorEntry
+            };
+        }), MAX_PARALLEL_QUERIES);
+    const filteredResults = results.filter(isDefined);
+    const nextCursors = filteredResults.map((r)=>r.nextCursorEntry).filter(isDefined);
+    const mappedAssetIds = filteredResults.flatMap((r)=>r.mappings.filter(isClassicCadAssetMapping).map((m)=>m.assetId));
+    return {
+        assetIds: mappedAssetIds,
+        modelKeyWithCursors: nextCursors.length > 0 ? nextCursors : undefined
+    };
 }
-async function d(e, t, n, r) {
-	if (n !== void 0) try {
-		let e = JSON.parse(n);
-		if (_(e)) return e;
-	} catch {
-		throw Error(`Failed to parse cursor: ${n}`);
-	}
-	return {
-		strategy: await f(e, t, r),
-		cursors: {
-			assetCursor: void 0,
-			mappingCursor: void 0
-		}
-	};
+async function getCursorForStrategy(models, filters, cursor, sdk) {
+    if (cursor !== undefined) {
+        try {
+            const parsed = JSON.parse(cursor);
+            if (isCompoundCursor(parsed)) return parsed;
+        } catch  {
+            throw new Error(`Failed to parse cursor: ${cursor}`);
+        }
+    }
+    const strategy = await selectStrategy(models, filters, sdk);
+    return {
+        strategy,
+        cursors: {
+            assetCursor: undefined,
+            mappingCursor: undefined
+        }
+    };
 }
-async function f(e, r, i) {
-	let o = await p(i, r);
-	return (await n(e.map((e) => async () => m(i, e.modelId, e.revisionId)), a)).filter(t).reduce((e, t) => e + t, 0) <= o ? "scanFromAssetMappings" : "scanFromAsset";
+/**
+ * Determines the most efficient strategy for fetching assets based on the count
+ * of filtered assets vs the count of mapped assets. If the count of mapped assets
+ * is less than or equal to the count of filtered assets, we choose to scan from
+ * asset mappings. Otherwise, we scan from assets and filter based on mappings.
+ * @param models - The list of CAD models to consider in the search
+ * @param filters - The asset filters to apply when counting filtered assets
+ * @param sdk - The Cognite SDK instance to use for API calls
+ * @returns The selected strategy for fetching assets
+ */ async function selectStrategy(models, filters, sdk) {
+    const filteredCount = await getFilteredAssetsCount(sdk, filters);
+    const assetMappingsCounts = await executeParallel(models.map((model)=>async ()=>{
+            return getAssetMappingsCountForModel(sdk, model.modelId, model.revisionId);
+        }), MAX_PARALLEL_QUERIES);
+    const allMappedAssetIdsCount = assetMappingsCounts.filter(isDefined).reduce((sum, count)=>sum + count, 0);
+    return allMappedAssetIdsCount <= filteredCount ? 'scanFromAssetMappings' : 'scanFromAsset';
 }
-async function p(e, t) {
-	return (await e.post(`/api/v1/projects/${e.project}/assets/aggregate`, { data: {
-		aggregate: "count",
-		...t
-	} })).data.items[0]?.count ?? 0;
+async function getFilteredAssetsCount(sdk, filters) {
+    const response = await sdk.post(`/api/v1/projects/${sdk.project}/assets/aggregate`, {
+        data: {
+            aggregate: 'count',
+            ...filters
+        }
+    });
+    return response.data.items[0]?.count ?? 0;
 }
-async function m(e, t, n) {
-	return (await e.revisions3D.retrieve(t, n)).assetMappingCount ?? 0;
+/**
+ * Fetches the count of asset mappings for a given model revision.
+ * This is used in the strategy selection process to determine whether it's
+ * more efficient to scan from assets or from asset mappings.
+ * @param sdk - Cognite SDK instance
+ * @param modelId - ID of the CAD model
+ * @param revisionId - ID of the CAD model revision
+ * @returns The count of asset mappings for the specified model revision
+ */ async function getAssetMappingsCountForModel(sdk, modelId, revisionId) {
+    const revision = await sdk.revisions3D.retrieve(modelId, revisionId);
+    return revision.assetMappingCount ?? 0;
 }
-async function h(e, t, n, a, o, s, c = 20) {
-	let l = [], u = /* @__PURE__ */ new Set(), d = n.cursors.assetCursor, f = 0;
-	for (; f < c && l.length < t;) {
-		let { data: n, nextCursor: p } = await i({
-			assetIds: void 0,
-			filters: a,
-			cursor: d,
-			limit: t,
-			sdk: o,
-			maxRequestsPerPage: c
-		});
-		if (n.length > 0) {
-			let t = await g(e, n.map((e) => e.id), s), i = new Set(t.filter(r).map((e) => e.assetId)), a = n.filter((e) => i.has(e.id) && !u.has(e.id));
-			a.forEach((e) => u.add(e.id)), l.push(...a);
-		}
-		if (f++, p === void 0) return {
-			data: l,
-			nextCursor: void 0
-		};
-		d = p;
-	}
-	return {
-		data: l,
-		nextCursor: JSON.stringify({
-			strategy: n.strategy,
-			cursors: {
-				assetCursor: d,
-				mappingCursor: n.cursors.mappingCursor
-			}
-		})
-	};
+async function scanFromAssetsFilteredOnAssetMappings(cadModels, limit, parsedCursor, filters, sdk, cache, maxRequestsPerPage = 20) {
+    const collectedData = [];
+    const seenIds = new Set();
+    let currentCursor = parsedCursor.cursors.assetCursor;
+    let requestCount = 0;
+    while(requestCount < maxRequestsPerPage && collectedData.length < limit){
+        const { items: assets, nextCursor: nextAssetCursor } = await fetchAssetPage({
+            assetIds: undefined,
+            filters,
+            cursor: currentCursor,
+            limit,
+            sdk,
+            maxRequestsPerPage
+        });
+        if (assets.length > 0) {
+            const assetIds = assets.map((a)=>a.id);
+            const mappedIds = await getMappedIdsAcrossModels(cadModels, assetIds, cache);
+            const mappedAssetIdSet = new Set(mappedIds.filter(isClassicCadAssetMapping).map((m)=>m.assetId));
+            const newAssets = assets.filter((a)=>mappedAssetIdSet.has(a.id) && !seenIds.has(a.id));
+            newAssets.forEach((a)=>seenIds.add(a.id));
+            collectedData.push(...newAssets);
+        }
+        requestCount++;
+        if (nextAssetCursor === undefined) {
+            return {
+                data: collectedData,
+                nextCursor: undefined
+            };
+        }
+        currentCursor = nextAssetCursor;
+    }
+    return {
+        data: collectedData,
+        nextCursor: JSON.stringify({
+            strategy: parsedCursor.strategy,
+            cursors: {
+                assetCursor: currentCursor,
+                mappingCursor: parsedCursor.cursors.mappingCursor
+            }
+        })
+    };
 }
-async function g(e, t, n) {
-	return (await Promise.all(e.map((e) => n.getAssetMappingsForInstanceIds(e.modelId, e.revisionId, t)))).flat();
+async function getMappedIdsAcrossModels(cadModels, assetIds, cache) {
+    const mappedIdSets = await Promise.all(cadModels.map((model)=>cache.getAssetMappingsForInstanceIds(model.modelId, model.revisionId, assetIds)));
+    return mappedIdSets.flat();
 }
-function _(e) {
-	return typeof e == "object" && !!e && "strategy" in e && (e.strategy === "scanFromAsset" || e.strategy === "scanFromAssetMappings");
+function isCompoundCursor(cursor) {
+    return typeof cursor === 'object' && cursor !== null && 'strategy' in cursor && (cursor.strategy === 'scanFromAsset' || cursor.strategy === 'scanFromAssetMappings');
 }
-//#endregion
-export { c as searchClassicAssetsForCadModels };
+export async function filterClassicAssetsOnCadAssetMappings(cadModels, assetsToScanFrom, cache) {
+    const assetIds = assetsToScanFrom.map((a)=>a.id);
+    const mappedIds = await getMappedIdsAcrossModels(cadModels, assetIds, cache);
+    const mappedAssetIdSet = mappedIds.reduce((acc, id)=>{
+        if (isClassicCadAssetMapping(id)) {
+            acc.add(id.assetId);
+        }
+        return acc;
+    }, new Set());
+    const filteredAssets = assetsToScanFrom.filter((a)=>mappedAssetIdSet.has(a.id));
+    return new Map(filteredAssets.map((asset)=>[
+            asset.id,
+            asset
+        ]));
+}
+
+//# sourceMappingURL=searchClassicAssetsForCadModels.js.map