Function buildDBReferenceTree

src/DBClone.ts:90–819

(
  packPath: string,
  currentDBTableSelection: DBTableSelection,
  deepCloneTarget: { row: number; col: number },
  existingRefs: DBCell[],
  selectedNodesByName: IViewerTreeNodeWithData[],
  existingTree?: IViewerTreeNodeWithData
)

};

export const buildDBReferenceTree = async (
  packPath: string,
  currentDBTableSelection: DBTableSelection,
  deepCloneTarget: { row: number; col: number },
  existingRefs: DBCell[],
  selectedNodesByName: IViewerTreeNodeWithData[],
  existingTree?: IViewerTreeNodeWithData
): Promise<IViewerTreeNodeWithData | undefined> => {
  console.log("ENTER buildDBReferenceTree");
  console.log("args:", packPath, currentDBTableSelection, deepCloneTarget, selectedNodesByName);
  const DBNameToDBVersions = gameToDBNameToDBVersions[appData.currentGame];
  const DBFieldsReferencedBy = gameToDBFieldsReferencedBy[appData.currentGame];
  const tableToreferencedColumns = gameToReferences[appData.currentGame];
  const packedFilePath = getDBPackedFilePath(currentDBTableSelection);

  const gameFolderPaths = appData.gamesToGameFolderPaths[appData.currentGame];
  if (!gameFolderPaths || !gameFolderPaths.dataFolder) return;

  const nodePath = await import("path");
  const dataPackPath = nodePath.join(
    gameFolderPaths.dataFolder,
    gameToPackWithDBTablesName[appData.currentGame]
  );

  const isCurrentPackDataPack = nodePath.relative(packPath, dataPackPath) == "";

  const isStartingSearchIndirect = selectedNodesByName.length > 0;

  console.log("isStartingSearchIndirect:", isStartingSearchIndirect);
  console.log("isCurrentPackDataPack:", isCurrentPackDataPack);

  const packsWithReadLocsByPackPath = [] as string[];

  let existingPack = appData.packsData.find((pack) => pack.path == packPath);
  if (!existingPack) {
    await readModsByPath([packPath], { skipParsingTables: true }, true);

    existingPack = appData.packsData.find((pack) => pack.path == packPath);
    if (!existingPack) {
      console.log("buildDBReferenceTree: no existingPack");
      return;
    }
  }

  if (!isCurrentPackDataPack) {
    let tablesToReadInDataPack = existingPack.packedFiles
      .filter((pf) => pf.schemaFields && pf.name.startsWith("db\\"))
      .map((pf) => `db\\${getDBNameFromString(pf.name)}`);

    tablesToReadInDataPack = Array.from(new Set(tablesToReadInDataPack));
    console.log("tables to read from data pack:", tablesToReadInDataPack);

    if (!wasPackAlreadyReadAll(dataPackPath, tablesToReadInDataPack)) {
      await readModsByPath([dataPackPath], { tablesToRead: tablesToReadInDataPack }, true);
      const existingDataPack = appData.packsData.find((pack) => pack.path == dataPackPath);
      if (existingDataPack) {
        getPacksTableData([existingDataPack], tablesToReadInDataPack);
      }