@leonxin/meetgames 0.1.7 → 0.1.11

package/src/ios/pbxprojEditor.ts

@@ -0,0 +1,383 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import type { TextFileStore } from "../ops/fileStore.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type XcodeProject = any;
+
+const require = createRequire(import.meta.url);
+const xcode = require("xcode") as {
+  project: (pbxprojPath: string) => XcodeProject;
+};
+
+export interface PbxContext {
+  rel: string;
+  proj: XcodeProject;
+  srcRoot: string;
+  targetName: string;
+}
+
+function parseProjectFromContent(content: string): Promise<XcodeProject> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meet-pbx-"));
+  const pbxprojPath = path.join(dir, "project.pbxproj");
+  fs.writeFileSync(pbxprojPath, content, "utf8");
+  return new Promise((resolve, reject) => {
+    const proj = xcode.project(pbxprojPath);
+    proj.parse((err: Error | null) => {
+      if (err) reject(err);
+      else resolve(proj);
+    });
+  });
+}
+
+function ensureObjectSection(proj: XcodeProject, sectionName: string): void {
+  const objects = proj.hash?.project?.objects as Record<string, unknown> | undefined;
+  if (!objects) return;
+  if (!objects[sectionName]) objects[sectionName] = {};
+}
+
+function objectSection(proj: XcodeProject, sectionName: string): Record<string, unknown> {
+  ensureObjectSection(proj, sectionName);
+  return (proj.hash.project.objects as Record<string, Record<string, unknown>>)[sectionName];
+}
+
+export async function loadPbxFromStore(
+  store: TextFileStore,
+  projectRoot: string,
+  xcodeprojPath: string,
+  targetName: string
+): Promise<PbxContext> {
+  const rel = path.relative(projectRoot, path.join(xcodeprojPath, "project.pbxproj")).split(path.sep).join("/");
+  const content = store.read(rel);
+  const proj = await parseProjectFromContent(content);
+  // Newer Xcode projects can omit empty sections, while the `xcode` package assumes
+  // sections such as PBXBuildFile already exist before adding frameworks/resources.
+  ensureObjectSection(proj, "PBXBuildFile");
+  ensureObjectSection(proj, "PBXFileReference");
+  const xcodeprojDir = path.dirname(xcodeprojPath);
+  let srcRoot = xcodeprojDir;
+  const first = proj.getFirstProject?.()?.firstProject;
+  const projectDirPath = first?.projectDirPath
+    ? String(first.projectDirPath).replace(/^"|"$/g, "").trim()
+    : "";
+  if (projectDirPath.length > 0) {
+    srcRoot = path.resolve(xcodeprojDir, projectDirPath);
+  }
+  return { rel, proj, srcRoot, targetName };
+}
+
+export function savePbxToStore(store: TextFileStore, ctx: PbxContext): void {
+  store.write(ctx.rel, ctx.proj.writeSync());
+}
+
+function targetUuid(proj: XcodeProject, targetName: string): string | undefined {
+  const targets = proj.pbxNativeTargetSection?.() ?? {};
+  for (const [uuid, t] of Object.entries(targets)) {
+    if (uuid.endsWith("_comment")) continue;
+    const name = (t as { name?: string }).name?.replace(/"/g, "");
+    if (name === targetName) return uuid;
+  }
+  return undefined;
+}
+
+function targetKey(proj: XcodeProject, targetName: string): string {
+  const uuid = targetUuid(proj, targetName);
+  if (!uuid) throw new Error(`Xcode target not found: ${targetName}`);
+  return uuid;
+}
+
+function ensureResourcesBuildPhase(proj: XcodeProject, targetName: string): void {
+  const target = targetKey(proj, targetName);
+  try {
+    proj.pbxResourcesBuildPhaseObj(target);
+    return;
+  } catch {
+    proj.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", target);
+  }
+}
+
+export function addThirdPartyFramework(ctx: PbxContext, relPathFromSrcRoot: string, embed: boolean): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(file, {
+    customFramework: true,
+    embed,
+    sign: true,
+    target,
+  });
+}
+
+export function addCopyFile(ctx: PbxContext, relPathFromSrcRoot: string): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  if (copyFilesPhaseJson(ctx, target).includes(path.basename(file))) return;
+  ensureCopyFilesBuildPhase(ctx, target);
+  addCopyFileManually(ctx, target, file);
+}
+
+function copyFilesPhaseJson(ctx: PbxContext, target: string): string {
+  try {
+    return JSON.stringify(ctx.proj.pbxCopyfilesBuildPhaseObj?.(target) ?? {});
+  } catch {
+    return "";
+  }
+}
+
+function findFileRefUuid(ctx: PbxContext, file: string): string | null {
+  const basename = path.basename(file);
+  const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+  for (const [uuid, raw] of Object.entries(fileRefSection)) {
+    if (uuid.endsWith("_comment") || !raw || typeof raw !== "object") continue;
+    const ref = raw as Record<string, unknown>;
+    const comment = fileRefSection[`${uuid}_comment`];
+    const refPath = String(ref.path ?? "").replace(/^"|"$/g, "");
+    const refName = String(ref.name ?? "").replace(/^"|"$/g, "");
+    if (comment === basename || refPath === file || refPath.endsWith(`/${basename}`) || refName === basename) {
+      return uuid;
+    }
+  }
+  return null;
+}
+
+function ensureCopyFilesBuildPhase(ctx: PbxContext, target: string): Record<string, unknown> {
+  const section = objectSection(ctx.proj, "PBXCopyFilesBuildPhase");
+  for (const [uuid, raw] of Object.entries(section)) {
+    if (uuid.endsWith("_comment") || !raw || typeof raw !== "object") continue;
+    const phase = raw as Record<string, unknown>;
+    const name = String(phase.name ?? "").replace(/^"|"$/g, "");
+    if (name === "Copy Files" || section[`${uuid}_comment`] === "Copy Files") {
+      phase.files = (phase.files as unknown[]) ?? [];
+      return phase;
+    }
+  }
+
+  const uuid = ctx.proj.generateUuid();
+  const phase: Record<string, unknown> = {
+    isa: "PBXCopyFilesBuildPhase",
+    buildActionMask: 2147483647,
+    dstPath: '""',
+    dstSubfolderSpec: 10,
+    files: [],
+    name: '"Copy Files"',
+    runOnlyForDeploymentPostprocessing: 0,
+  };
+  section[uuid] = phase;
+  section[`${uuid}_comment`] = "Copy Files";
+  const native = ctx.proj.pbxNativeTargetSection?.()[target] as { buildPhases?: Array<{ value: string; comment: string }> };
+  native.buildPhases ??= [];
+  if (!native.buildPhases.some((p) => p.value === uuid)) {
+    native.buildPhases.push({ value: uuid, comment: "Copy Files" });
+  }
+  return phase;
+}
+
+function addCopyFileManually(ctx: PbxContext, target: string, file: string): void {
+  const basename = path.basename(file);
+  const phase = ensureCopyFilesBuildPhase(ctx, target);
+  const files = (phase.files ??= []) as Array<{ value?: string; comment?: string }>;
+  if (JSON.stringify(files).includes(basename)) return;
+
+  let fileRefUuid: string = findFileRefUuid(ctx, file) ?? "";
+  if (!fileRefUuid) {
+    fileRefUuid = ctx.proj.generateUuid();
+    const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+    fileRefSection[fileRefUuid] = {
+      isa: "PBXFileReference",
+      name: `"${basename}"`,
+      path: `"${file}"`,
+      sourceTree: '"<group>"',
+      lastKnownFileType: "wrapper.framework",
+      includeInIndex: 0,
+    };
+    fileRefSection[`${fileRefUuid}_comment`] = basename;
+  }
+
+  const buildUuid = ctx.proj.generateUuid();
+  const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
+  buildFileSection[buildUuid] = {
+    isa: "PBXBuildFile",
+    fileRef: fileRefUuid,
+    fileRef_comment: basename,
+  };
+  buildFileSection[`${buildUuid}_comment`] = `${basename} in Copy Files`;
+  files.push({ value: buildUuid, comment: `${basename} in Copy Files` });
+}
+
+export function addSystemFramework(ctx: PbxContext, frameworkName: string): void {
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(`System/Library/Frameworks/${frameworkName}`, {
+    customFramework: false,
+    weak: false,
+    target,
+  });
+}
+
+export function addSystemLib(ctx: PbxContext, libName: string): void {
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(`usr/lib/${libName}`, {
+    customFramework: false,
+    weak: false,
+    target,
+  });
+}
+
+export function addSourceOrResourceFile(ctx: PbxContext, relPathFromSrcRoot: string): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  if (file.endsWith(".h")) {
+    ctx.proj.addHeaderFile(file, { target });
+  } else if (file.endsWith(".m") || file.endsWith(".mm") || file.endsWith(".swift")) {
+    ctx.proj.addSourceFile(file, { target });
+  } else {
+    ensureResourcesBuildPhase(ctx.proj, ctx.targetName);
+    const opt: Record<string, unknown> = { target };
+    if (file.endsWith(".xcdatamodeld")) {
+      opt.lastKnownFileType = "wrapper.xcdatamodel";
+    }
+    try {
+      ctx.proj.addResourceFile(file, opt);
+    } catch (e) {
+      if (!String(e instanceof Error ? e.message : e).includes("path")) throw e;
+      addResourceFileManually(ctx, file, typeof opt.lastKnownFileType === "string" ? opt.lastKnownFileType : undefined);
+    }
+  }
+}
+
+function resourceFileType(file: string, lastKnownFileType?: string): string {
+  if (lastKnownFileType) return lastKnownFileType;
+  if (file.endsWith(".bundle")) return "wrapper.plug-in";
+  if (file.endsWith(".xcdatamodeld")) return "wrapper.xcdatamodel";
+  if (file.endsWith(".xcassets")) return "folder.assetcatalog";
+  if (file.endsWith(".plist")) return "text.plist.xml";
+  return "unknown";
+}
+
+function addResourceFileManually(ctx: PbxContext, file: string, lastKnownFileType?: string): void {
+  const basename = path.basename(file);
+  const resources = ctx.proj.pbxResourcesBuildPhaseObj(targetKey(ctx.proj, ctx.targetName));
+  const files = (resources.files ??= []) as Array<{ value?: string; comment?: string }>;
+  if (JSON.stringify(files).includes(basename)) return;
+
+  const fileRefUuid = ctx.proj.generateUuid();
+  const buildUuid = ctx.proj.generateUuid();
+  const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+  const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
+
+  fileRefSection[fileRefUuid] = {
+    isa: "PBXFileReference",
+    name: `"${basename}"`,
+    path: `"${file}"`,
+    sourceTree: '"<group>"',
+    lastKnownFileType: resourceFileType(file, lastKnownFileType),
+    includeInIndex: 0,
+  };
+  fileRefSection[`${fileRefUuid}_comment`] = basename;
+  buildFileSection[buildUuid] = {
+    isa: "PBXBuildFile",
+    fileRef: fileRefUuid,
+    fileRef_comment: basename,
+  };
+  buildFileSection[`${buildUuid}_comment`] = `${basename} in Resources`;
+  files.push({ value: buildUuid, comment: `${basename} in Resources` });
+}
+
+export function setBuildSetting(ctx: PbxContext, key: string, value: string): void {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return;
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return;
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    settings[key] = value;
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+  }
+}
+
+export function addOtherLinkerFlag(ctx: PbxContext, flag: string): void {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return;
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return;
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    const cur = settings.OTHER_LDFLAGS;
+    if (typeof cur === "string") {
+      if (!cur.includes(flag)) settings.OTHER_LDFLAGS = `${cur} ${flag}`.trim();
+    } else if (Array.isArray(cur)) {
+      if (!cur.includes(flag)) settings.OTHER_LDFLAGS = [...cur, flag];
+    } else {
+      settings.OTHER_LDFLAGS = [flag];
+    }
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+  }
+}
+
+export function getTargetBuildSettings(ctx: PbxContext): Array<Record<string, unknown>> {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return [];
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return [];
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  const out: Array<Record<string, unknown>> = [];
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+    out.push(settings);
+  }
+  return out;
+}
+
+export function findInfoPlistPathsFromPbx(ctx: PbxContext): string[] {
+  const paths = new Set<string>();
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return [];
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return [];
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    const settings = (cfg as { buildSettings?: Record<string, string> })?.buildSettings;
+    const info = settings?.INFOPLIST_FILE;
+    if (!info) continue;
+    let resolved = info.replace(/"/g, "");
+    if (resolved.includes("$(SRCROOT)")) {
+      resolved = resolved.replace(/\$\(SRCROOT\)/g, ctx.srcRoot);
+    } else if (!path.isAbsolute(resolved)) {
+      resolved = path.join(ctx.srcRoot, resolved);
+    }
+    resolved = path.normalize(resolved);
+    paths.add(resolved);
+  }
+  return [...paths];
+}
+
+export function ensureInfoPlistInProject(ctx: PbxContext, _targetName: string, relPlist: string): void {
+  setBuildSetting(ctx, "GENERATE_INFOPLIST_FILE", "NO");
+  setBuildSetting(ctx, "INFOPLIST_FILE", relPlist);
+}

package/src/ios/pluginConfig.ts

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { LoadedPluginConfig, PluginConfigJson } from "./types.js";
+
+const CONFIG_FILENAMES = ["config.t.json", "config.json"] as const;
+
+function findConfigFileInDir(dir: string): string | null {
+  for (const name of CONFIG_FILENAMES) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function normalizePluginConfig(raw: Record<string, unknown>): PluginConfigJson {
+  const flags =
+    (raw.OtherLinkerFlags as string[] | undefined) ??
+    (raw.otherLinkerFlags as string[] | undefined) ??
+    [];
+  return {
+    ...(raw as unknown as PluginConfigJson),
+    OtherLinkerFlags: flags,
+  };
+}
+
+function parseConfigJson(filePath: string): PluginConfigJson {
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8")) as Record<string, unknown>;
+  const config = normalizePluginConfig(raw);
+  if (!config.name || typeof config.type !== "number") {
+    throw new Error(`invalid plugin config (missing name/type): ${filePath}`);
+  }
+  return config;
+}
+
+function resolveSourceDir(sdkRoot: string, config: PluginConfigJson, pluginDir: string): string {
+  const sdkDir = path.join(sdkRoot, "sdk");
+  if (config.type === 0) {
+    return path.join(sdkDir, "source");
+  }
+  return path.join(pluginDir, "source");
+}
+
+export function loadPluginConfig(configPath: string, sdkRoot: string): LoadedPluginConfig {
+  const abs = path.resolve(configPath);
+  const pluginDir = path.dirname(abs);
+  const config = parseConfigJson(abs);
+  const sourceDir = resolveSourceDir(sdkRoot, config, pluginDir);
+  return { configPath: abs, pluginDir, sourceDir, config };
+}
+
+/** Core SDK manifests: `sdk/*.json` (e.g. topsdkConfig.t.json). */
+export function listSdkCoreConfigs(sdkRoot: string): LoadedPluginConfig[] {
+  const sdkDir = path.join(sdkRoot, "sdk");
+  if (!fs.existsSync(sdkDir)) return [];
+  const out: LoadedPluginConfig[] = [];
+  for (const name of fs.readdirSync(sdkDir)) {
+    if (!name.endsWith(".json") || name.startsWith(".")) continue;
+    out.push(loadPluginConfig(path.join(sdkDir, name), sdkRoot));
+  }
+  return out;
+}
+
+export function findPluginByFolder(sdkRoot: string, folderName: string): LoadedPluginConfig | null {
+  const pluginDir = path.join(sdkRoot, "plugins", folderName);
+  const cfg = findConfigFileInDir(pluginDir);
+  if (!cfg) return null;
+  return loadPluginConfig(cfg, sdkRoot);
+}
+
+export function validateLoadedPluginResources(loaded: LoadedPluginConfig): string[] {
+  const errors: string[] = [];
+  const { config, sourceDir, pluginDir, configPath } = loaded;
+  const dirName = path.basename(pluginDir);
+  const isKnownDataManagerAlias = config.type === 4 && dirName.endsWith("Manager");
+  if (config.type !== 0 && dirName !== config.name && !isKnownDataManagerAlias) {
+    errors.push(`plugin config name mismatch: ${configPath} name=${config.name} dir=${path.basename(pluginDir)}`);
+  }
+  if (!fs.existsSync(sourceDir)) {
+    errors.push(`plugin source directory not found: ${sourceDir}`);
+    return errors;
+  }
+  for (const source of config.sources ?? []) {
+    const p = path.join(sourceDir, source);
+    if (!fs.existsSync(p)) errors.push(`missing source resource for ${config.name}: ${source}`);
+  }
+  for (const fw of config.frameworks ?? []) {
+    if (fw.system) continue;
+    const p = path.join(sourceDir, fw.name);
+    if (!fs.existsSync(p)) errors.push(`missing framework resource for ${config.name}: ${fw.name}`);
+  }
+  for (const lib of config.libs ?? []) {
+    if (lib.system) continue;
+    const p = path.join(sourceDir, lib.name);
+    if (!fs.existsSync(p)) errors.push(`missing lib resource for ${config.name}: ${lib.name}`);
+  }
+  return errors;
+}

package/src/ios/reserved.ts

@@ -0,0 +1,8 @@
+import type { IosToolingReserved } from "../contracts/types.js";
+
+export const iosToolingReserved: IosToolingReserved = {
+  status: "implemented",
+  plan: ["framework-copy", "pbxproj", "plist", "app-delegate"],
+};
+
+export { detectIOS as detectIOSPlaceholder } from "./detect.js";

package/src/ios/sdkBundle.ts

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const BUNDLED_IOS_REL = path.join("bundled", "ios-sdk");
+
+export function defaultBundledIosSdkRoot(packageRoot: string): string {
+  return path.join(packageRoot, BUNDLED_IOS_REL);
+}
+
+/**
+ * TopSDK iOS package root: `bundled/ios-sdk` or a child version dir (e.g. `ios--V1.6.0.4/`).
+ * Native iOS only; SDK is vendored in the tool package.
+ */
+export function resolveIosSdkRoot(packageRoot: string): string {
+  const bundled = defaultBundledIosSdkRoot(packageRoot);
+  if (!fs.existsSync(bundled)) {
+    throw new Error(`iOS SDK not found at ${BUNDLED_IOS_REL} (expected sdk/ and plugins/ inside).`);
+  }
+  const children = fs
+    .readdirSync(bundled, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
+    .map((d) => path.join(bundled, d.name))
+    .sort()
+    .reverse();
+  for (const dir of children) {
+    if (fs.existsSync(path.join(dir, "sdk")) && fs.existsSync(path.join(dir, "plugins"))) {
+      return dir;
+    }
+  }
+  if (fs.existsSync(path.join(bundled, "sdk")) && fs.existsSync(path.join(bundled, "plugins"))) {
+    return bundled;
+  }
+  throw new Error(
+    `iOS SDK layout invalid under ${BUNDLED_IOS_REL}: need sdk/ + plugins/ at top level or under one version directory.`
+  );
+}

package/src/ios/template.ts

@@ -0,0 +1,36 @@
+/** Substitute `{path.to.value}` placeholders using channel config (topsdk-tool-ios `checkStr`). */
+export function applyChannelTemplate(value: string, channelConfig: Record<string, unknown>): string {
+  let result = value;
+  const re = /\{([^}]+)\}/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(value)) !== null) {
+    const token = m[1].startsWith("$C.") ? m[1].slice(3) : m[1];
+    const parts = token.split(".");
+    let cur: unknown = channelConfig;
+    for (const p of parts) {
+      if (cur && typeof cur === "object" && p in (cur as Record<string, unknown>)) {
+        cur = (cur as Record<string, unknown>)[p];
+      } else {
+        cur = "";
+        break;
+      }
+    }
+    const replacement = cur == null ? "" : String(cur);
+    result = result.replace(m[0], replacement);
+  }
+  return result;
+}
+
+export function applyChannelTemplateValue(value: unknown, channelConfig: Record<string, unknown>): unknown {
+  if (typeof value === "string") return applyChannelTemplate(value, channelConfig);
+  if (Array.isArray(value)) return value.map((item) => applyChannelTemplateValue(item, channelConfig));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+        key,
+        applyChannelTemplateValue(item, channelConfig),
+      ])
+    );
+  }
+  return value;
+}

package/src/ios/types.ts

@@ -0,0 +1,65 @@
+export interface FrameworkConfig {
+  name: string;
+  system: boolean;
+  embed: boolean;
+  copyFile?: boolean;
+}
+
+export interface LibConfig {
+  name: string;
+  system: boolean;
+}
+
+export interface CodeConfig {
+  type: "header" | "method" | "code";
+  method?: string;
+  content: string;
+  addToReturn?: boolean;
+}
+
+export interface PluginConfigJson {
+  name: string;
+  pluginVersion: string;
+  key: string;
+  type: number;
+  frameworks?: FrameworkConfig[];
+  libs?: LibConfig[];
+  sources?: string[];
+  buildSettings?: Record<string, string>;
+  OtherLinkerFlags?: string[];
+  queriesSchemes?: string[];
+  urlScheme?: string;
+  infoParams?: Record<string, unknown>;
+  requireConfigs?: string[];
+  pluginParams?: Record<string, string>;
+  appDelegateCodes?: CodeConfig[];
+  sceneDelegateCodes?: CodeConfig[];
+}
+
+export interface LoadedPluginConfig {
+  configPath: string;
+  pluginDir: string;
+  sourceDir: string;
+  config: PluginConfigJson;
+}
+
+export type PerformSetting =
+  | "sources"
+  | "frameworks"
+  | "libs"
+  | "buildSettings"
+  | "OtherLinkerFlags"
+  | "queriesSchemes"
+  | "infoParams"
+  | "urlScheme";
+
+export const DEFAULT_PERFORM_SETTINGS: readonly PerformSetting[] = [
+  "sources",
+  "frameworks",
+  "libs",
+  "buildSettings",
+  "OtherLinkerFlags",
+  "queriesSchemes",
+  "infoParams",
+  "urlScheme",
+];