@leonxin/meetgames 0.1.8 → 0.1.12

package/src/config/loadAndroidIntegration.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import type { ErrorObject } from "ajv";
+import type { AndroidIntegrationDocument } from "../contracts/types.js";
+
+const require = createRequire(import.meta.url);
+const Ajv: typeof import("ajv").default = require("ajv") as typeof import("ajv").default;
+const addFormats = require("ajv-formats") as (ajv: import("ajv").default) => import("ajv").default;
+
+const ajv = new Ajv({ allErrors: true, strict: true });
+addFormats(ajv);
+
+let validateCached: ReturnType<typeof ajv.compile<AndroidIntegrationDocument>> | undefined;
+
+function getValidator() {
+  if (validateCached) return validateCached;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const schemaPath = path.join(here, "..", "..", "schema", "android-integration.schema.json");
+  const raw = JSON.parse(fs.readFileSync(schemaPath, "utf8")) as object;
+  validateCached = ajv.compile<AndroidIntegrationDocument>(raw);
+  return validateCached;
+}
+
+export function parseAndroidIntegrationJson(data: unknown): AndroidIntegrationDocument {
+  const validate = getValidator();
+  if (!validate(data)) {
+    const msg =
+      validate.errors?.map((e: ErrorObject) => `${e.instancePath} ${e.message}`).join("; ") ||
+      "invalid android integration json";
+    throw new Error(`Android integration validation failed: ${msg}`);
+  }
+  return data as AndroidIntegrationDocument;
+}
+
+export function loadAndroidIntegrationFile(filePath: string): AndroidIntegrationDocument {
+  const text = fs.readFileSync(filePath, "utf8");
+  const data: unknown = JSON.parse(text);
+  return parseAndroidIntegrationJson(data);
+}

package/src/config/loadManifest.ts

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import type { ErrorObject } from "ajv";
+import yaml from "js-yaml";
+import type { Manifest } from "../contracts/types.js";
+
+const require = createRequire(import.meta.url);
+const Ajv: typeof import("ajv").default = require("ajv") as typeof import("ajv").default;
+const addFormats = require("ajv-formats") as (ajv: import("ajv").default) => import("ajv").default;
+
+const ajv = new Ajv({ allErrors: true, strict: true });
+addFormats(ajv);
+
+let validateCached: ReturnType<typeof ajv.compile<Manifest>> | undefined;
+
+function getValidator() {
+  if (validateCached) return validateCached;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const schemaPath = path.join(here, "..", "..", "schema", "manifest.schema.json");
+  const raw = JSON.parse(fs.readFileSync(schemaPath, "utf8")) as object;
+  validateCached = ajv.compile<Manifest>(raw);
+  return validateCached;
+}
+
+export function loadManifestFile(filePath: string): Manifest {
+  const text = fs.readFileSync(filePath, "utf8");
+  const ext = path.extname(filePath).toLowerCase();
+  const data: unknown =
+    ext === ".yaml" || ext === ".yml" ? yaml.load(text) : JSON.parse(text);
+  const validate = getValidator();
+  if (!validate(data)) {
+    const msg =
+      validate.errors?.map((e: ErrorObject) => `${e.instancePath} ${e.message}`).join("; ") ||
+      "invalid manifest";
+    throw new Error(`Manifest validation failed: ${msg}`);
+  }
+  return data as Manifest;
+}

package/src/config/meetSdkDefaultConfig.ts

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { tryParseAsMeetSdkDefaultConfig, type MeetSdkDefaultConfig } from "./meetSdkRemoteConfig.js";
+import { defaultSdkHomeApiBaseUrl, fetchSdkHomeVersions, type SdkHomePlatformVersion } from "../remote/sdkHomeDownload.js";
+
+/** Built-in Android SDK defaults (repos and per-plugin dependencies). */
+export const MEETSDK_ANDROID_DEFAULTS_FILENAME = "meetsdk-android.json";
+const MEETSDK_CONFIG_DIR = "config";
+
+const defaultConfigPath = fileURLToPath(
+  new URL(`../../${MEETSDK_CONFIG_DIR}/${MEETSDK_ANDROID_DEFAULTS_FILENAME}`, import.meta.url)
+);
+
+export function resolveMeetSdkAndroidConfigPath(packageRoot?: string): string {
+  return packageRoot ? path.join(packageRoot, MEETSDK_CONFIG_DIR, MEETSDK_ANDROID_DEFAULTS_FILENAME) : defaultConfigPath;
+}
+
+export function loadBuiltInMeetSdkDefaultConfig(options: { packageRoot?: string } = {}): MeetSdkDefaultConfig {
+  const configPath = resolveMeetSdkAndroidConfigPath(options.packageRoot);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `built-in ${MEETSDK_ANDROID_DEFAULTS_FILENAME} not found at ${configPath}; reinstall @leonxin/meetgames or run from a complete package install`
+    );
+  }
+  const raw = JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown;
+  const parsed = tryParseAsMeetSdkDefaultConfig(raw);
+  if (!parsed) {
+    throw new Error(`built-in ${MEETSDK_ANDROID_DEFAULTS_FILENAME} is not a valid MeetSdk default config`);
+  }
+  return parsed;
+}
+
+function cloneDefaultConfig(value: MeetSdkDefaultConfig): MeetSdkDefaultConfig {
+  return JSON.parse(JSON.stringify(value)) as MeetSdkDefaultConfig;
+}
+
+function resolveSdkHomeApiBaseUrl(baseUrl?: string): string {
+  return baseUrl || process.env.MEETGAMES_SDK_HOME_API_BASE_URL?.trim() || defaultSdkHomeApiBaseUrl;
+}
+
+const latestAndroidVersionCache = new Map<string, Promise<SdkHomePlatformVersion>>();
+
+async function fetchLatestAndroidSdkVersion(baseUrl?: string): Promise<SdkHomePlatformVersion> {
+  const resolvedBaseUrl = resolveSdkHomeApiBaseUrl(baseUrl);
+  let cached = latestAndroidVersionCache.get(resolvedBaseUrl);
+  if (!cached) {
+    cached = fetchSdkHomeVersions({ baseUrl: resolvedBaseUrl }).then(({ versions }) => versions.android);
+    latestAndroidVersionCache.set(resolvedBaseUrl, cached);
+  }
+  return cached;
+}
+
+export function syncMeetSdkAndroidVersionToConfig(params: {
+  version: string;
+  date?: string;
+  packageRoot?: string;
+}): string {
+  const version = params.version.trim();
+  if (!version) throw new Error("Android SDK version is empty");
+
+  const configPath = resolveMeetSdkAndroidConfigPath(params.packageRoot);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`built-in ${MEETSDK_ANDROID_DEFAULTS_FILENAME} not found at ${configPath}`);
+  }
+  const raw = JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`built-in ${MEETSDK_ANDROID_DEFAULTS_FILENAME} is not a JSON object`);
+  }
+  const record = raw as Record<string, unknown>;
+  if (typeof record.topsdk !== "object" || record.topsdk === null || Array.isArray(record.topsdk)) {
+    throw new Error(`built-in ${MEETSDK_ANDROID_DEFAULTS_FILENAME} does not contain topsdk object`);
+  }
+  const topsdk = record.topsdk as Record<string, unknown>;
+  topsdk.version = version;
+  if (params.date?.trim()) topsdk.date = params.date.trim();
+  fs.writeFileSync(configPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+  return configPath;
+}
+
+/**
+ * Built-in Android SDK defaults with the SDK version resolved at runtime from sdk-home.
+ * The version is also persisted to `config/meetsdk-android.json` so the package config
+ * reflects the latest SDK version discovered from the download center.
+ */
+export async function loadMeetSdkDefaultConfigWithLatestAndroidVersion(options: {
+  sdkHomeApiBaseUrl?: string;
+  packageRoot?: string;
+} = {}): Promise<MeetSdkDefaultConfig> {
+  const defaults = cloneDefaultConfig(loadBuiltInMeetSdkDefaultConfig({ packageRoot: options.packageRoot }));
+  const latest = await fetchLatestAndroidSdkVersion(options.sdkHomeApiBaseUrl);
+  syncMeetSdkAndroidVersionToConfig({
+    version: latest.ver,
+    date: latest.date,
+    packageRoot: options.packageRoot,
+  });
+  defaults.topsdk.version = latest.ver;
+  defaults.topsdk.date = latest.date;
+  return defaults;
+}

package/src/config/meetSdkIosConfig.ts

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const MEETSDK_IOS_CONFIG_FILENAME = "meetsdk-ios.json";
+const MEETSDK_CONFIG_DIR = "config";
+
+export interface MeetSdkIosConfig {
+  topsdk: {
+    version: string;
+    date?: string;
+    packageType?: string;
+    plugins?: string[];
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function str(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizePlugins(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const plugins = value.map((x) => String(x).trim()).filter(Boolean);
+  return plugins.length ? plugins : undefined;
+}
+
+export function resolveMeetSdkIosConfigPath(packageRoot: string): string {
+  return path.join(packageRoot, MEETSDK_CONFIG_DIR, MEETSDK_IOS_CONFIG_FILENAME);
+}
+
+export function tryParseAsMeetSdkIosConfig(raw: unknown): MeetSdkIosConfig | null {
+  if (!isRecord(raw)) return null;
+  const topsdk = isRecord(raw.topsdk) ? raw.topsdk : {};
+  return {
+    topsdk: {
+      version: str(topsdk.version),
+      date: str(topsdk.date) || undefined,
+      packageType: str(topsdk.packageType) || undefined,
+      plugins: normalizePlugins(topsdk.plugins),
+    },
+  };
+}
+
+export function loadMeetSdkIosConfig(packageRoot: string): MeetSdkIosConfig {
+  const configPath = resolveMeetSdkIosConfigPath(packageRoot);
+  if (!fs.existsSync(configPath)) {
+    return { topsdk: { version: "" } };
+  }
+  const parsed = tryParseAsMeetSdkIosConfig(JSON.parse(fs.readFileSync(configPath, "utf8")) as unknown);
+  if (!parsed) {
+    throw new Error(`${MEETSDK_IOS_CONFIG_FILENAME} is not a valid MeetSdk iOS config`);
+  }
+  return parsed;
+}
+
+export function writeMeetSdkIosConfig(packageRoot: string, config: MeetSdkIosConfig): string {
+  const configPath = resolveMeetSdkIosConfigPath(packageRoot);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  return configPath;
+}
+
+export function syncMeetSdkIosVersionToConfig(params: {
+  packageRoot: string;
+  version: string;
+  date?: string;
+  packageType?: string;
+  plugins?: readonly string[];
+}): string {
+  const version = params.version.trim();
+  if (!version) throw new Error("iOS SDK version is empty");
+
+  const current = loadMeetSdkIosConfig(params.packageRoot);
+  const nextDate = params.date === undefined ? current.topsdk.date : params.date.trim() || undefined;
+  const next: MeetSdkIosConfig = {
+    ...current,
+    topsdk: {
+      ...current.topsdk,
+      version,
+      date: nextDate,
+      packageType: params.packageType?.trim() || current.topsdk.packageType,
+      plugins: params.plugins?.map((x) => x.trim()).filter(Boolean) || current.topsdk.plugins,
+    },
+  };
+  return writeMeetSdkIosConfig(params.packageRoot, next);
+}