Function applyPackageImport

src/services/packageImportService.ts:493–807

(
	options: ApplyImportOptions,
)

}

export async function applyPackageImport(
	options: ApplyImportOptions,
): Promise<ApplyImportResult> {
	const { app, existingChoices, pkg } = options;
	const choiceDecisionMap: Map<string, ChoiceImportMode> = new Map(
		options.choiceDecisions.map((decision) => [decision.choiceId, decision.mode]),
	);
	const assetDecisionMap: Map<string, AssetImportDecision> = new Map(
		options.assetDecisions.map((decision) => [decision.originalPath, decision]),
	);

	const catalog = new Map(pkg.choices.map((entry) => [entry.choice.id, entry]));
	const secretOptionNamesByPath = buildSecretOptionNamesByPath(pkg);
	const importableChoiceIds = new Set<string>();
	const importableCache = new Map<string, boolean>();
	const importableVisiting = new Set<string>();

	const isChoiceImportable = (choiceId: string): boolean => {
		const finalizeImportable = (isImportable: boolean): boolean => {
			importableCache.set(choiceId, isImportable);
			importableVisiting.delete(choiceId);
			return isImportable;
		};

		if (importableCache.has(choiceId)) {
			return importableCache.get(choiceId) as boolean;
		}

		if (importableVisiting.has(choiceId)) {
			// Break potential cycles by treating the current path as importable.
			return true;
		}

		importableVisiting.add(choiceId);

		const decision = choiceDecisionMap.get(choiceId);
		if (decision === "skip") {
			return finalizeImportable(false);
		}

		const entry = catalog.get(choiceId);
		if (!entry) {
			return finalizeImportable(false);
		}

		const parentId = entry.parentChoiceId;
		if (!parentId) {
			return finalizeImportable(true);
		}

		if (!catalog.has(parentId)) {
			return finalizeImportable(true);
		}

		const parentDecision = choiceDecisionMap.get(parentId);
		if (parentDecision === "skip") {
			return finalizeImportable(true);
		}