Function parseBundleConfig

src/core/cocos3x/bundleConfig.js:22–122

* Inflate a raw config.json per the same logic the runtime uses at load time. * * @param {object} raw Parsed config.json. * @param {string} baseDir Absolute path to the bundle directory (the one that * contains config.json + import/ + native/). * @returns {BundleConf

(raw, baseDir)

 * @returns {BundleConfig}
 */
function parseBundleConfig(raw, baseDir) {
  const debug = raw.debug === true;
  const importBase = raw.importBase || 'import';
  const nativeBase = raw.nativeBase || 'native';
  const name = raw.name || path.basename(baseDir);
  const types = Array.isArray(raw.types) ? raw.types : [];
  const deps = Array.isArray(raw.deps) ? raw.deps : [];
  const uuidsRaw = Array.isArray(raw.uuids) ? raw.uuids : [];

  // Expand compressed uuids unless the config is in debug mode.
  const uuids = uuidsRaw.map(u => (debug ? u : uuidUtils.decodeUuid(u)));

  // Versions: flat [idx, ver, idx, ver, ...] arrays per kind.
  const importVersions = indexedVersionMap(raw.versions && raw.versions.import, uuids);
  const nativeVersions = indexedVersionMap(raw.versions && raw.versions.native, uuids);

  // Paths: { "<uuidIndex>": [relPath, typeIndex, subAssetFlag?] }
  const rawPaths = raw.paths && typeof raw.paths === 'object' ? raw.paths : {};
  const paths = {};
  for (const key of Object.keys(rawPaths)) {
    const entry = rawPaths[key];
    const uuidIdx = parseInt(key, 10);
    if (!Array.isArray(entry) || Number.isNaN(uuidIdx)) continue;
    const uuid = uuids[uuidIdx];
    if (!uuid) continue;
    const relPath = entry[0];
    const typeIndex = entry[1];
    const subAssetFlag = entry[2];
    paths[uuid] = {
      path: relPath,
      type: typeIndex != null ? types[typeIndex] : null,
      subAsset: subAssetFlag === 1 || subAssetFlag === true,
    };
  }

  // Scenes: { name: "<uuidIndex>" } -> { name: uuid }
  const rawScenes = raw.scenes && typeof raw.scenes === 'object' ? raw.scenes : {};
  const scenes = {};
  for (const sceneName of Object.keys(rawScenes)) {
    const idx = parseInt(rawScenes[sceneName], 10);
    const uuid = Number.isNaN(idx) ? rawScenes[sceneName] : uuids[idx];
    if (uuid) scenes[sceneName] = uuid;
  }

  // Packs: { packUuid(compressed): [childUuidIdx or childUuid] }
  const rawPacks = raw.packs && typeof raw.packs === 'object' ? raw.packs : {};
  const packs = {};
  for (const packKey of Object.keys(rawPacks)) {
    const packUuid = debug ? packKey : uuidUtils.decodeUuid(packKey);
    const children = rawPacks[packKey];
    if (!Array.isArray(children)) continue;
    packs[packUuid] = children.map(c => {
      const idx = parseInt(c, 10);
      if (!Number.isNaN(idx) && uuids[idx]) return uuids[idx];
      return debug ? c : uuidUtils.decodeUuid(c);
    });
  }