@expo-harmony/patch-project 55.1.27-harmony.1

package/README.md

@@ -0,0 +1,89 @@
+# @expo-harmony/patch-project
+
+[**GitHub 仓库**](https://github.com/renbaoshuo/expo-harmony/tree/master/packages/patch-project)
+
+这个包把 `harmony/` 里的手动修改保存为 Git 补丁，在 prebuild 时自动应用回去。它提供生成补丁的命令和负责应用补丁的 config plugin，流程对应 Expo 官方的 [patch-project](https://docs.expo.dev/config-plugins/patch-project/)。
+
+## 安装
+
+```sh
+npm install @expo-harmony/patch-project
+```
+
+在 app config 的 `plugins` 里注册插件：
+
+```json
+{
+  "expo": {
+    "plugins": ["@expo-harmony/patch-project"]
+  }
+}
+```
+
+## 生成补丁
+
+先跑一次 prebuild 得到 `harmony/`，手动改完后执行：
+
+```sh
+npx @expo-harmony/patch-project
+# 指定项目目录
+npx @expo-harmony/patch-project ./my-app
+```
+
+命令把当前原生工程和 prebuild 生成的默认工程做比较，将差异存储成一个 patch。patch 会存放在 `cng-patches/harmony+<templateChecksum>.patch`，把 `cng-patches/` 提交到仓库即可。
+
+## 应用补丁
+
+跑 `expo-harmony prebuild` 或 `expo-harmony prebuild --clean`，插件查找并应用与当前模板匹配的补丁。没有补丁就照常生成；只有其他模板的补丁时发出警告并跳过，提示重新审查和生成。有多份补丁时只应用校验和匹配的那一份。
+
+补丁在常规 Mods、自定义文件 Mods 和 autolinking 之后应用。补丁新增的文件纳入 CNG 文件管理，改补丁或移除插件时会清掉不再声明的新增文件。既有文件上的修改不会自动撤销，要完整重建就用 `prebuild --clean`。
+
+## 选项
+
+命令参数：
+
+| 参数                    | 作用                                                     |
+| ----------------------- | -------------------------------------------------------- |
+| `--clean`               | 补丁保存成功后删除原生目录，下次 prebuild 重新生成再应用 |
+| `-p, --platform <name>` | `harmony` 或 `all`，默认 `harmony`，两者都只处理 Harmony |
+| `-h, --help`            | 显示帮助                                                 |
+
+插件选项：
+
+| 选项                | 默认值        | 说明                                   |
+| ------------------- | ------------- | -------------------------------------- |
+| `patchRoot`         | `cng-patches` | 查找补丁的目录，相对项目根目录         |
+| `changedLinesLimit` | `300`         | 补丁改动行数超过该值时警告，不阻止应用 |
+
+```json
+[
+  "@expo-harmony/patch-project",
+  {
+    "patchRoot": "cng-patches",
+    "changedLinesLimit": 300
+  }
+]
+```
+
+`patchRoot` 必须是非空路径，`changedLinesLimit` 必须是非负数。
+
+注意生成 patch 的命令只往 `cng-patches/` 写补丁，插件配置使用别的目录查找 patch 时，需要自己把 patch 文件移过去。
+
+## 支持的修改
+
+支持文本和二进制文件、新增和删除，以及可执行权限等修改，还有指向 Harmony 工程内部的相对符号链接。
+
+文件是否进入补丁遵循 `harmony/.gitignore` 及其子目录中的 Git 忽略规则。默认的 prebuild 模板已忽略常见的依赖目录和构建产物，需要保留其中的文件时，可以用 `!` 规则显式包含。
+
+补丁路径和符号链接不能越出 Harmony 工程，也不能修改 `.git` 元数据。
+
+## 升级
+
+SDK、模板或其他插件升级后补丁可能对不上，要重新审查并生成。改动量大、长期维护的配置更适合写成静态 Mod。
+
+## Author
+
+**expo-harmony** © [Baoshuo](https://github.com/renbaoshuo), Released under the MIT License.<br>
+Authored and maintained by Baoshuo with help from [contributors](https://github.com/renbaoshuo/expo-harmony/contributors).
+
+> [Personal Website](https://baoshuo.ren) · [Blog](https://blog.baoshuo.ren) · GitHub [@renbaoshuo](https://github.com/renbaoshuo) · Twitter [@renbaoshuo](https://twitter.com/renbaoshuo)

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./build/withPatchPlugin').default;

package/build/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/cli/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const errors_1 = require("../errors");
+const patchProjectAsync_1 = require("./patchProjectAsync");
+async function main() {
+    const { values, positionals } = (0, node_util_1.parseArgs)({
+        allowPositionals: true,
+        options: {
+            help: { type: 'boolean', short: 'h' },
+            clean: { type: 'boolean' },
+            platform: { type: 'string', short: 'p', default: 'harmony' },
+        },
+    });
+    if (values.help) {
+        console.log(`Usage: npx @expo-harmony/patch-project [project] [options]
+
+Preserve manual Harmony native changes as CNG patches.
+
+Options:
+  --clean                 Delete harmony/ after successfully saving the patch
+  -p, --platform <name>    harmony or all (default: harmony)
+  -h, --help               Show this help`);
+        return;
+    }
+    if (positionals.length > 1 || !['harmony', 'all'].includes(values.platform)) {
+        throw new errors_1.HarmonyPatchError('ERR_HARMONY_CONFIG_INVALID', 'Expected one project directory and --platform harmony or all.');
+    }
+    const root = await promises_1.default.realpath(node_path_1.default.resolve(positionals[0] || '.'));
+    await promises_1.default.access(node_path_1.default.join(root, 'package.json'));
+    process.env.EXPO_HARMONY = '1';
+    process.env.EXPO_METRO_TARGET = 'harmony';
+    const file = await (0, patchProjectAsync_1.patchProjectAsync)(root, { clean: values.clean });
+    console.log(file ? `Saved Harmony patch: ${file}` : 'No manual changes detected; removed previous Harmony patches.');
+    if (file)
+        console.log('Add "@expo-harmony/patch-project" to your app config plugins to apply patches during prebuild.');
+}
+main().catch((cause) => {
+    console.error(`[${cause.code || 'ERR_HARMONY_PATCH_FAILED'}] ${cause.message}`);
+    process.exitCode = 1;
+});

package/build/cli/patchProjectAsync.d.ts

@@ -0,0 +1,3 @@
+export declare function patchProjectAsync(root: string, options?: {
+    clean?: boolean;
+}): Promise<string>;

package/build/cli/patchProjectAsync.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchProjectAsync = patchProjectAsync;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const prebuild_1 = require("@expo-harmony/cli/internal/prebuild");
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const errors_1 = require("../errors");
+const gitPatch_1 = require("../gitPatch");
+const patches_1 = require("../patches");
+async function patchProjectAsync(root, options = {}) {
+    return (0, prebuild_1.withHarmonyProjectLockAsync)(root, 'patch-project', async () => {
+        const native = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(root, 'harmony');
+        let stat;
+        try {
+            stat = await promises_1.default.lstat(native);
+        }
+        catch (cause) {
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Cannot read the harmony directory. Run prebuild first.', {
+                cause, file: native,
+            });
+        }
+        if (!stat.isDirectory() || !(await promises_1.default.readdir(native)).length) {
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'The harmony directory must exist and contain a native project. Run prebuild first.');
+        }
+        if (options.clean)
+            await (0, prebuild_1.assertSafeCleanTarget)(root);
+        const directory = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(root, 'cng-patches');
+        const previous = await (0, patches_1.getPatchFilesAsync)(directory);
+        const result = await (0, prebuild_1.withGeneratedProjectAsync)(root, { clean: true, skipPatches: true }, async (expected, checksum) => ({
+            patch: await (0, gitPatch_1.generatePatchAsync)(node_path_1.default.join(expected, 'harmony'), native),
+            file: node_path_1.default.join(directory, `harmony+${checksum}.patch`),
+        }));
+        if (result.patch.trim())
+            await (0, config_plugins_1.atomicWrite)(result.file, result.patch);
+        for (const name of previous) {
+            const file = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(directory, name);
+            if (!result.patch.trim() || file !== result.file)
+                await promises_1.default.rm(file);
+        }
+        if (options.clean)
+            await promises_1.default.rm(native, { recursive: true });
+        return result.patch.trim() ? result.file : null;
+    });
+}

package/build/errors.d.ts

@@ -0,0 +1,4 @@
+import { HarmonyConfigPluginError, type HarmonyConfigPluginErrorOptions } from '@expo-harmony/config-plugins';
+export declare class HarmonyPatchError extends HarmonyConfigPluginError {
+    constructor(code: string, message: string, options?: HarmonyConfigPluginErrorOptions);
+}

package/build/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyPatchError = void 0;
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+class HarmonyPatchError extends config_plugins_1.HarmonyConfigPluginError {
+    constructor(code, message, options = {}) {
+        super(code, message, { operation: 'patch-project', ...options });
+        this.name = 'HarmonyPatchError';
+    }
+}
+exports.HarmonyPatchError = HarmonyPatchError;

package/build/gitPatch.d.ts

@@ -0,0 +1,7 @@
+export declare function generatePatchAsync(baseline: string, current: string): Promise<string>;
+export interface PatchResult {
+    files: string[];
+    created: string[];
+}
+export declare function getPatchChangedLinesAsync(file: string): Promise<number>;
+export declare function applyPatchAsync(root: string, content: string): Promise<PatchResult>;

package/build/gitPatch.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePatchAsync = generatePatchAsync;
+exports.getPatchChangedLinesAsync = getPatchChangedLinesAsync;
+exports.applyPatchAsync = applyPatchAsync;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const errors_1 = require("./errors");
+const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function isProjectPath(relative) {
+    // eslint-disable-next-line no-control-regex -- Control characters are invalid native patch paths.
+    return !!relative && !relative.includes('\\') && !/[\x00-\x1f\x7f]/u.test(relative)
+        && !relative.split('/').some(part => !part || part === '.' || part === '..' || part.toLowerCase() === '.git')
+        && !/^[A-Za-z]:/u.test(relative);
+}
+async function git(cwd, args) {
+    // Ambient Git overrides must not redirect commands outside the staging repository.
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
+    try {
+        return (await exec('git', [
+            '-c', 'core.autocrlf=false', '-c', 'core.quotePath=false', '-c', 'core.fileMode=true', ...args,
+        ], {
+            cwd,
+            env: { ...env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: process.platform === 'win32' ? 'NUL' : '/dev/null' },
+            maxBuffer: 64 * 1024 * 1024,
+        })).stdout;
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Git patch operation failed: ${cause.stderr || cause.message}`, { cause, operation: 'patch-project' });
+    }
+}
+async function listFiles(source) {
+    const staging = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'harmony-patch-files-'));
+    try {
+        await git(staging, ['init', '--quiet', '--bare']);
+        const output = await git(staging, [`--work-tree=${node_path_1.default.resolve(source)}`, 'ls-files', '--others', '--exclude-standard', '-z']);
+        return output.split('\0').filter(Boolean);
+    }
+    finally {
+        await promises_1.default.rm(staging, { recursive: true, force: true });
+    }
+}
+async function snapshot(source, target, files) {
+    await promises_1.default.mkdir(target, { recursive: true });
+    for (const name of files) {
+        if (!isProjectPath(name))
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Invalid native patch path: ${name}.`);
+        await config_plugins_1.HarmonyPaths.resolveHarmonyPath(source, name);
+        const from = node_path_1.default.join(source, name);
+        const to = node_path_1.default.join(target, name);
+        let stat;
+        try {
+            stat = await promises_1.default.lstat(from);
+        }
+        catch (cause) {
+            if (cause.code === 'ENOENT')
+                continue;
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Cannot inspect ${from}.`, { cause, file: from });
+        }
+        if (!stat.isFile() && !stat.isSymbolicLink())
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch source must be a file: ${from}.`);
+        await promises_1.default.mkdir(node_path_1.default.dirname(to), { recursive: true });
+        await promises_1.default.cp(from, to, { verbatimSymlinks: true });
+    }
+}
+async function changedFiles(root, patch) {
+    const stats = await git(root, ['apply', '--numstat', '-z', patch]);
+    const files = stats.split('\0').filter(Boolean).map((row) => {
+        const match = /^(?:\d+|-)\t(?:\d+|-)\t(harmony\/(.+))$/u.exec(row);
+        if (!match || !isProjectPath(match[2])) {
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Patch paths must remain inside the Harmony project and cannot modify Git metadata.');
+        }
+        return match[2];
+    });
+    return [...new Set(files)];
+}
+async function generatePatchAsync(baseline, current) {
+    const staging = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'harmony-patch-diff-'));
+    try {
+        await git(staging, ['init', '--quiet']);
+        const native = node_path_1.default.join(staging, 'harmony');
+        const files = await listFiles(baseline);
+        await snapshot(baseline, native, files);
+        // Temporary dependency paths must not appear in patches.
+        const root = await promises_1.default.realpath(node_path_1.default.dirname(baseline));
+        const file = node_path_1.default.join(root, '.expo/harmony/autolinking.json');
+        let manifest;
+        try {
+            manifest = await promises_1.default.readFile(file, 'utf8');
+        }
+        catch (cause) {
+            if (cause.code !== 'ENOENT') {
+                throw new errors_1.HarmonyPatchError(cause.code || 'ERR_HARMONY_PATCH_FAILED', cause.message || `Cannot read autolinking manifest ${file}.`, { cause, file, operation: 'patch-project' });
+            }
+        }
+        if (manifest) {
+            const file = node_path_1.default.join(native, config_plugins_1.HarmonyPaths.HARMONY_PATHS.rootOhPackage);
+            const canonical = (0, expo_modules_autolinking_1.canonicalizeAutolinkingArtifacts)({
+                manifestSource: manifest,
+                ohPackageSource: await promises_1.default.readFile(file, 'utf8'),
+                generatedProjectRoot: root,
+                canonicalProjectRoot: await promises_1.default.realpath(node_path_1.default.dirname(current)),
+                harmonyProjectPath: await promises_1.default.realpath(current),
+            });
+            await promises_1.default.writeFile(file, canonical.ohPackageSource);
+        }
+        await git(staging, ['add', '-f', '--all', '--', 'harmony']);
+        await promises_1.default.rm(native, { recursive: true });
+        await snapshot(current, native, [...new Set([...files, ...await listFiles(current)])]);
+        // Intent-to-add includes new text and binary files without changing baseline entries.
+        const untracked = (await git(staging, ['ls-files', '--others', '-z', '--', 'harmony'])).split('\0').filter(Boolean);
+        if (untracked.length)
+            await git(staging, ['add', '-f', '-N', '--', ...untracked]);
+        return await git(staging, [
+            'diff', '--binary', '--ignore-space-at-eol', '--no-renames', '--no-color', '--no-ext-diff', '--no-textconv', '--', 'harmony',
+        ]);
+    }
+    finally {
+        await promises_1.default.rm(staging, { recursive: true, force: true });
+    }
+}
+async function getPatchChangedLinesAsync(file) {
+    const stats = await git(node_path_1.default.dirname(file), ['apply', '--numstat', file]);
+    return stats.split('\n').reduce((total, row) => {
+        const [added, deleted] = row.split('\t', 2).map(Number);
+        return total + (Number.isFinite(added) ? added : 0) + (Number.isFinite(deleted) ? deleted : 0);
+    }, 0);
+}
+async function applyPatchAsync(root, content) {
+    if (!content.trim())
+        return { files: [], created: [] };
+    if (/^(?:old mode|new mode|new file mode|deleted file mode) (?!100644$|100755$|120000$)/mu.test(content)
+        || /^(?:rename|copy) (?:from|to) /mu.test(content)) {
+        throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Use file or symlink patches; regenerate renames as delete/add changes.');
+    }
+    const staging = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'harmony-patch-apply-'));
+    try {
+        await git(staging, ['init', '--quiet']);
+        const patch = node_path_1.default.join(staging, 'changes.patch');
+        await promises_1.default.writeFile(patch, content);
+        const files = await changedFiles(staging, patch);
+        const native = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(root, 'harmony');
+        await snapshot(native, node_path_1.default.join(staging, 'harmony'), files);
+        const chunks = content.split(/(?=^diff --git )/mu).filter(chunk => chunk.startsWith('diff --git '));
+        if (!chunks.length) {
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Expected a Git patch generated by npx @expo-harmony/patch-project.');
+        }
+        const sections = new Map();
+        for (const chunk of chunks) {
+            await promises_1.default.writeFile(patch, chunk);
+            const names = await changedFiles(staging, patch);
+            if (names.length !== 1)
+                throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Each patch section must modify one file.');
+            sections.set(names[0], (sections.get(names[0]) ?? '') + chunk);
+        }
+        const created = [];
+        for (const [name, source] of sections) {
+            if (/^new file mode /mu.test(source) && !/^deleted file mode /mu.test(source))
+                created.push(name);
+            await promises_1.default.writeFile(patch, source);
+            try {
+                await git(staging, ['apply', '--ignore-whitespace', '--check', patch]);
+            }
+            catch (cause) {
+                // Other mods may regenerate only some files. Accept already-applied
+                // sections independently, while validating the complete patch in staging.
+                try {
+                    await git(staging, ['apply', '--ignore-whitespace', '--reverse', '--check', patch]);
+                }
+                catch {
+                    throw new errors_1.HarmonyPatchError(cause.code, cause.message, {
+                        cause, file: patch, operation: cause.operation,
+                    });
+                }
+                continue;
+            }
+            await git(staging, ['apply', '--ignore-whitespace', '--binary', patch]);
+        }
+        if (sections.size !== files.length || files.some(file => !sections.has(file))) {
+            throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', 'Patch section paths do not match its file summary.');
+        }
+        const writes = [];
+        for (const file of files) {
+            const target = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(native, file);
+            const staged = node_path_1.default.join(staging, 'harmony', file);
+            let stat;
+            try {
+                stat = await promises_1.default.lstat(staged);
+            }
+            catch (cause) {
+                if (cause.code !== 'ENOENT') {
+                    throw new errors_1.HarmonyPatchError(cause.code || 'ERR_HARMONY_PATCH_FAILED', cause.message || `Cannot inspect staged patch output ${file}.`, { cause, file: staged, operation: 'patch-project' });
+                }
+            }
+            if (stat?.isSymbolicLink()) {
+                const link = await promises_1.default.readlink(staged);
+                if (node_path_1.default.isAbsolute(link) || !config_plugins_1.HarmonyPaths.isInside(native, node_path_1.default.resolve(node_path_1.default.dirname(target), link))) {
+                    throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch symlink must remain inside the Harmony project: ${file}.`);
+                }
+                await config_plugins_1.HarmonyPaths.resolveHarmonyPath(native, node_path_1.default.relative(native, node_path_1.default.resolve(node_path_1.default.dirname(target), link)));
+                writes.push({ target, link });
+            }
+            else if (stat?.isFile()) {
+                writes.push({ target, content: Uint8Array.from(await promises_1.default.readFile(staged)), mode: stat.mode & 0o777 });
+            }
+            else if (!stat)
+                writes.push({ target });
+            else
+                throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Patch output must be a file: ${file}.`);
+        }
+        for (const { target, content, link, mode } of writes) {
+            if (content) {
+                await (0, config_plugins_1.atomicWrite)(target, content);
+                await promises_1.default.chmod(target, mode);
+            }
+            else {
+                await promises_1.default.rm(target, { force: true });
+                if (link !== undefined) {
+                    await promises_1.default.mkdir(node_path_1.default.dirname(target), { recursive: true });
+                    await promises_1.default.symlink(link, target);
+                }
+            }
+        }
+        return { files, created };
+    }
+    finally {
+        await promises_1.default.rm(staging, { recursive: true, force: true });
+    }
+}

package/build/patches.d.ts

@@ -0,0 +1 @@
+export declare function getPatchFilesAsync(root: string): Promise<string[]>;

package/build/patches.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPatchFilesAsync = getPatchFilesAsync;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const errors_1 = require("./errors");
+async function getPatchFilesAsync(root) {
+    try {
+        return (await promises_1.default.readdir(root)).filter(name => name.startsWith('harmony') && name.endsWith('.patch')).sort();
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return [];
+        throw new errors_1.HarmonyPatchError('ERR_HARMONY_PATCH_FAILED', `Cannot read patch directory ${root}.`, { cause, file: root });
+    }
+}

package/build/withPatchPlugin.d.ts

@@ -0,0 +1,7 @@
+import { type HarmonyConfigPlugin } from '@expo-harmony/config-plugins';
+export interface PatchPluginProps {
+    patchRoot?: string;
+    changedLinesLimit?: number;
+}
+declare const _default: HarmonyConfigPlugin<void | PatchPluginProps>;
+export default _default;

package/build/withPatchPlugin.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const internal_1 = require("@expo-harmony/config-plugins/internal");
+const config_plugins_2 = require("@expo/config-plugins");
+const errors_1 = require("./errors");
+const gitPatch_1 = require("./gitPatch");
+const patches_1 = require("./patches");
+const owner = '@expo-harmony/patch-project';
+const withPatchPlugin = (config, props) => {
+    const options = props || {};
+    const limit = options.changedLinesLimit ?? 300;
+    if ((options.patchRoot !== undefined && (typeof options.patchRoot !== 'string' || !options.patchRoot.trim()))
+        || !Number.isFinite(limit) || limit < 0) {
+        throw new errors_1.HarmonyPatchError('ERR_HARMONY_CONFIG_INVALID', 'patchRoot must be a non-empty directory path and changedLinesLimit must be a non-negative number.');
+    }
+    (0, config_plugins_1.registerHarmonyConfigPlugin)(config, owner);
+    return (0, internal_1.withProjectPatch)(config, async (mod) => {
+        if (mod.modRequest.introspect || process.env.EXPO_HARMONY_SKIP_PATCHES === '1')
+            return mod;
+        const root = mod.modRequest.projectRoot;
+        const directory = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(root, options.patchRoot ?? 'cng-patches');
+        const files = await (0, patches_1.getPatchFilesAsync)(directory);
+        if (!files.length)
+            return mod;
+        const checksum = mod._internal?.templateChecksum;
+        const name = `harmony+${checksum}.patch`;
+        if (!checksum || !files.includes(name)) {
+            config_plugins_2.WarningAggregator.addWarningForPlatform('harmony', owner, `No patch matches the current template${checksum ? ` (${checksum})` : ''}. Existing Harmony patches were not applied. Review and regenerate them with npx @expo-harmony/patch-project.`);
+            return mod;
+        }
+        if (files.length > 1) {
+            config_plugins_2.WarningAggregator.addWarningForPlatform('harmony', owner, `Multiple Harmony patches found; only ${name} will be applied.`);
+        }
+        const file = await config_plugins_1.HarmonyPaths.resolveHarmonyPath(directory, name);
+        const source = await promises_1.default.readFile(file, 'utf8');
+        if (!source.trim())
+            return mod;
+        const changed = await (0, gitPatch_1.getPatchChangedLinesAsync)(file);
+        if (changed > limit) {
+            config_plugins_2.WarningAggregator.addWarningForPlatform('harmony', owner, `${name} has ${changed} changed lines, exceeding the warning limit of ${limit}. Consider a config plugin for larger changes.`);
+        }
+        const result = await (0, gitPatch_1.applyPatchAsync)(root, source);
+        (0, config_plugins_1.registerHarmonyConfigPlugin)(mod, owner, { files: result.created });
+        for (const relative of result.files) {
+            const file = node_path_1.default.join(mod.modRequest.platformProjectRoot, relative);
+            const managed = mod._internal?.harmonyManagedFiles?.find(item => item.path === `harmony/${relative}`);
+            (0, config_plugins_1.recordManagedFile)(mod, file, managed?.owner ?? (result.created.includes(relative) ? owner : 'patch'));
+        }
+        return mod;
+    });
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withPatchPlugin, owner);

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@expo-harmony/patch-project",
+  "version": "55.1.27-harmony.1",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-harmony",
+    "harmonyos"
+  ],
+  "homepage": "https://github.com/renbaoshuo/expo-harmony/tree/master/packages/patch-project#readme",
+  "bugs": "https://github.com/renbaoshuo/expo-harmony/issues",
+  "license": "MIT",
+  "author": "Baoshuo <i@baoshuo.ren>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/renbaoshuo/expo-harmony.git",
+    "directory": "packages/patch-project"
+  },
+  "main": "build/withPatchPlugin.js",
+  "types": "build/withPatchPlugin.d.ts",
+  "scripts": {
+    "prebuild": "yarn workspace @expo-harmony/cli build",
+    "build": "tsc -p tsconfig.json",
+    "prepare": "yarn build",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "exports": {
+    ".": {
+      "types": "./build/withPatchPlugin.d.ts",
+      "require": "./build/withPatchPlugin.js",
+      "default": "./build/withPatchPlugin.js"
+    },
+    "./app.plugin.js": "./app.plugin.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@expo-harmony/cli": "55.0.26-harmony.9",
+    "@expo-harmony/config-plugins": "55.0.10-harmony.3",
+    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.3",
+    "@expo/config": "55.0.17",
+    "@expo/config-plugins": "55.0.10"
+  },
+  "peerDependencies": {
+    "expo": "55.0.26"
+  },
+  "devDependencies": {
+    "@types/node": "18.19.0",
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Preserve manual Harmony native changes with CNG patches",
+  "bin": {
+    "expo-harmony-patch-project": "build/cli/index.js"
+  },
+  "files": [
+    "app.plugin.js",
+    "build"
+  ]
+}