@expo-harmony/expo-modules-autolinking 55.0.25-harmony.1

package/build/src/types.d.ts

@@ -0,0 +1,194 @@
+export type Platform = 'harmony';
+export type BuildType = 'debug' | 'release';
+export type ModuleSource = 'dependency' | 'searchPath' | 'nativeModulesDir' | 'reactNativeProjectConfig';
+export interface ArkTsModulePackage {
+    /** Conventional package-relative HAR exporting the ArkTS module classes. */
+    readonly harPath: string;
+    /** OHPM package name read from the Harmony library manifest. */
+    readonly ohPackageName: string;
+}
+export interface HostMetadata {
+    readonly rootViewComponents: ReadonlyArray<string>;
+}
+export type ExpoMetadata = HostMetadata;
+export interface RnohMetadata {
+    readonly ohPackageName?: string | ReadonlyArray<{
+        readonly harName: string;
+        readonly packageName: string;
+        readonly version?: string;
+    }>;
+    readonly mainHarPath?: string;
+    readonly harPaths: ReadonlyArray<string>;
+    readonly etsPackageClassName?: string;
+    readonly etsPackageImport?: 'default' | 'named';
+    readonly cppPackageClassName?: string;
+    readonly cmakeLibraryTargetName?: string;
+}
+export interface HarmonyModuleMetadata extends HostMetadata {
+    /** ArkTS Module classes exported by the conventional Harmony library. */
+    readonly modules: ReadonlyArray<string>;
+}
+export interface FixedHvigorBuildDescriptor {
+    readonly executable: 'hvigorw';
+    readonly cwd: string;
+    readonly args: ReadonlyArray<string>;
+}
+export type ModuleArtifactDescriptor = {
+    readonly kind: 'bundled';
+    readonly harPaths: ReadonlyArray<string>;
+} | {
+    readonly kind: 'local-source';
+    readonly outputPath: string;
+    readonly materialized: false;
+    readonly build: FixedHvigorBuildDescriptor;
+};
+export interface ModuleDescriptor {
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly packageRoot: string;
+    /** Reachable package path used to install the bundled HAR during a native build. */
+    readonly packageLinkPath: string;
+    readonly source: ModuleSource;
+    /** Host extension declarations consumed by the generated application provider. */
+    readonly expo: ExpoMetadata;
+    /** RNOH package metadata read from package.json#harmony.autolinking. */
+    readonly rnoh: RnohMetadata;
+    /** Expo module author metadata from expo-module.config.json#harmony. */
+    readonly harmony: HarmonyModuleMetadata;
+    /** Build/package data derived from the conventional Harmony project, never author config. */
+    readonly arkTs?: ArkTsModulePackage;
+    readonly artifact: ModuleArtifactDescriptor;
+}
+export interface SearchRecord {
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly packageRoot: string;
+    readonly source: ModuleSource;
+    readonly supportsHarmony: boolean;
+    readonly expoModuleConfig: Readonly<Record<string, unknown>> | null;
+    readonly rnohMetadata: unknown;
+    readonly revision: {
+        readonly depth: number | null;
+        readonly originPath: string;
+    };
+}
+export interface SearchResult {
+    readonly platform: Platform;
+    readonly modules: ReadonlyArray<SearchRecord>;
+    readonly duplicates: ReadonlyArray<{
+        readonly packageName: string;
+        readonly revisions: ReadonlyArray<{
+            readonly version: string;
+            readonly path: string;
+        }>;
+    }>;
+    readonly missingIncludes: ReadonlyArray<string>;
+    readonly options: {
+        readonly projectRoot: string;
+        readonly searchPaths: ReadonlyArray<string>;
+        readonly nativeModulesDir: string | null;
+        readonly exclude: ReadonlyArray<string>;
+        readonly include: ReadonlyArray<string>;
+        readonly buildType: BuildType;
+    };
+}
+export interface DiagnosticSource {
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly packageRoot: string;
+    readonly field?: string;
+}
+export interface Diagnostic {
+    readonly severity: 'error' | 'warning';
+    readonly code: string;
+    readonly message: string;
+    readonly packageName?: string;
+    readonly stage: string;
+    readonly sources?: ReadonlyArray<DiagnosticSource>;
+}
+export interface VerificationResult {
+    readonly valid: boolean;
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+    readonly modules: ReadonlyArray<ModuleDescriptor>;
+}
+export interface Manifest {
+    readonly schemaVersion: 3;
+    readonly platform: 'harmony';
+    readonly buildType: BuildType;
+    readonly modules: ReadonlyArray<ModuleDescriptor>;
+    readonly managedArtifacts: ReadonlyArray<string>;
+}
+export interface CanonicalizeAutolinkingArtifactsOptions {
+    readonly manifestSource: string;
+    readonly ohPackageSource: string;
+    readonly generatedProjectRoot: string;
+    readonly canonicalProjectRoot: string;
+    readonly harmonyProjectPath?: string;
+}
+export interface CanonicalizedAutolinkingArtifacts {
+    readonly manifest: Manifest;
+    readonly manifestSource: string;
+    readonly ohPackageSource: string;
+}
+export interface Logger {
+    debug?(message: string, details?: unknown): void;
+    info?(message: string, details?: unknown): void;
+    warn?(message: string, details?: unknown): void;
+    error?(message: string, details?: unknown): void;
+}
+export interface SearchOptions {
+    projectRoot?: string;
+    platform?: Platform;
+    searchPaths?: ReadonlyArray<string>;
+    nativeModulesDir?: string | null;
+    exclude?: ReadonlyArray<string>;
+    include?: ReadonlyArray<string>;
+    buildType?: BuildType;
+    logger?: Logger;
+}
+export interface ResolveOptions extends SearchOptions {
+    searchResult?: SearchResult;
+}
+export interface VerifyOptions extends ResolveOptions {
+    modules?: ReadonlyArray<ModuleDescriptor>;
+}
+export interface LinkOptions extends VerifyOptions {
+    projectRoot: string;
+    harmonyProjectPath: string;
+    nodeModulesPath?: string;
+    reactNativeExecutable?: string;
+    rnohCliPackageJsonPath?: string;
+    timeoutMs?: number;
+    outputLimit?: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface MaterializeLocalSourceOptions {
+    readonly projectRoot: string;
+    readonly module: ModuleDescriptor;
+    readonly timeoutMs?: number;
+    readonly outputLimit?: number;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface MaterializedLocalSource {
+    readonly packageName: string;
+    readonly harPath: string;
+}
+export interface LinkResult {
+    readonly platform: Platform;
+    readonly modules: ReadonlyArray<ModuleDescriptor>;
+    readonly buildType: BuildType;
+    readonly managedArtifacts: ReadonlyArray<string>;
+    readonly changedArtifacts: ReadonlyArray<string>;
+    readonly unchangedArtifacts: ReadonlyArray<string>;
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+    readonly warnings: ReadonlyArray<Diagnostic>;
+}
+export interface AutolinkingErrorJson {
+    readonly name: 'HarmonyAutolinkingError';
+    readonly code: string;
+    readonly message: string;
+    readonly stage: string;
+    readonly packageName?: string;
+    readonly diagnostics?: ReadonlyArray<Diagnostic>;
+    readonly details?: unknown;
+}

package/build/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/utilities/values.d.ts

@@ -0,0 +1,17 @@
+declare function isObject(value: any): boolean;
+declare function compareText(left: any, right: any): 1 | -1 | 0;
+declare function sortedUniqueStrings(items: ReadonlyArray<string>): string[];
+declare function uniqueStrings(items: ReadonlyArray<string>): string[];
+declare function stringifyJson(value: any): string;
+declare function normalizeSlashes(value: any): any;
+declare function readJsonAsync(file: any, code?: string, stage?: string): Promise<any>;
+declare function pathExistsAsync(target: any): Promise<boolean>;
+declare function resolvePackageFromProject(projectRoot: any, specifier: any): string;
+declare function isPathInside(parent: any, child: any): boolean;
+declare function realpathExistingAsync(target: any, options?: Record<string, any>): Promise<string>;
+declare function resolveInsideAsync(root: any, relative: any, field: any, options?: Record<string, any>): Promise<any>;
+declare function requireNonEmptyString(value: any, field: any, options?: Record<string, any>): string;
+declare function normalizeStringArray(value: any, field: any, options?: Record<string, any>): any[];
+declare function sanitizeOutput(value: any, roots?: any[], limit?: number): string;
+declare function emitLog(logger: any, level: any, message: any, details: any): void;
+export { compareText, emitLog, isObject, isPathInside, normalizeSlashes, pathExistsAsync, resolvePackageFromProject, readJsonAsync, realpathExistingAsync, requireNonEmptyString, resolveInsideAsync, sanitizeOutput, stringifyJson, sortedUniqueStrings, normalizeStringArray, uniqueStrings, };

package/build/src/utilities/values.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareText = compareText;
+exports.emitLog = emitLog;
+exports.isObject = isObject;
+exports.isPathInside = isPathInside;
+exports.normalizeSlashes = normalizeSlashes;
+exports.pathExistsAsync = pathExistsAsync;
+exports.resolvePackageFromProject = resolvePackageFromProject;
+exports.readJsonAsync = readJsonAsync;
+exports.realpathExistingAsync = realpathExistingAsync;
+exports.requireNonEmptyString = requireNonEmptyString;
+exports.resolveInsideAsync = resolveInsideAsync;
+exports.sanitizeOutput = sanitizeOutput;
+exports.stringifyJson = stringifyJson;
+exports.sortedUniqueStrings = sortedUniqueStrings;
+exports.normalizeStringArray = normalizeStringArray;
+exports.uniqueStrings = uniqueStrings;
+const node_module_1 = require("node:module");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../errors");
+function isObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function sortedUniqueStrings(items) {
+    return [...new Set(items)].sort(compareText);
+}
+function uniqueStrings(items) {
+    return [...new Set(items)];
+}
+function stringifyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function normalizeSlashes(value) {
+    return value.split(path.sep).join('/');
+}
+async function readJsonAsync(file, code = 'INVALID_METADATA', stage = 'metadata') {
+    try {
+        return JSON.parse(await fs.promises.readFile(file, 'utf8'));
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError(code, `Unable to read valid JSON from ${file}.`, { cause, stage });
+    }
+}
+async function pathExistsAsync(target) {
+    try {
+        await fs.promises.access(target);
+        return true;
+    }
+    catch (_cause) {
+        return false;
+    }
+}
+function resolvePackageFromProject(projectRoot, specifier) {
+    return (0, node_module_1.createRequire)(path.join(projectRoot, 'package.json')).resolve(specifier);
+}
+function isPathInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function realpathExistingAsync(target, options = {}) {
+    const type = options.type || 'path';
+    const code = options.code || 'INVALID_OPTIONS';
+    const stage = options.stage || 'validation';
+    const field = options.field || 'path';
+    try {
+        const resolved = await fs.promises.realpath(path.resolve(target));
+        const stat = await fs.promises.stat(resolved);
+        if (type === 'directory' && !stat.isDirectory())
+            throw new TypeError('not a directory');
+        if (type === 'file' && !stat.isFile())
+            throw new TypeError('not a file');
+        return resolved;
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError(code, `${field} does not reference an existing ${type}: ${target}`, {
+            cause,
+            stage,
+        });
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function resolveInsideAsync(root, relative, field, options = {}) {
+    const mustExist = options.mustExist !== false;
+    const type = options.type || 'path';
+    const packageName = options.packageName;
+    if (typeof relative !== 'string' || !relative.trim() || path.isAbsolute(relative)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${field} must be a non-empty package-relative path.`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    const realRoot = await fs.promises.realpath(root);
+    const lexical = path.resolve(realRoot, relative);
+    if (!isPathInside(realRoot, lexical)) {
+        throw new errors_1.HarmonyAutolinkingError('PATH_OUTSIDE_PACKAGE', `${field} escapes package root.`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    if (!mustExist)
+        return lexical;
+    let resolved;
+    try {
+        resolved = await fs.promises.realpath(lexical);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${field} does not exist: ${relative}`, {
+            cause,
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    if (!isPathInside(realRoot, resolved)) {
+        throw new errors_1.HarmonyAutolinkingError('PATH_OUTSIDE_PACKAGE', `${field} resolves outside package root.`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    const stat = await fs.promises.stat(resolved);
+    if (type === 'file' && !stat.isFile()) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${field} must reference a file: ${relative}`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    if (type === 'directory' && !stat.isDirectory()) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${field} must reference a directory: ${relative}`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    return resolved;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function requireNonEmptyString(value, field, options = {}) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new errors_1.HarmonyAutolinkingError(options.code || 'INVALID_METADATA', `${field} must be a non-empty string.`, {
+            packageName: options.packageName,
+            stage: options.stage || 'metadata',
+        });
+    }
+    return value;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalizeStringArray(value, field, options = {}) {
+    if (value == null && options.optional)
+        return [];
+    const values = Array.isArray(value) ? value : options.allowScalar ? [value] : null;
+    if (!values || values.some(item => typeof item !== 'string' || !item.trim())) {
+        throw new errors_1.HarmonyAutolinkingError(options.code || 'INVALID_OPTIONS', `${field} must be an array of non-empty strings.`, {
+            packageName: options.packageName,
+            stage: options.stage || 'options',
+        });
+    }
+    return [...new Set(values)];
+}
+function sanitizeOutput(value, roots = [], limit = 8192) {
+    let result = String(value || '');
+    for (const root of roots.filter(Boolean))
+        result = result.split(root).join('<path>');
+    return result.slice(0, limit);
+}
+function emitLog(logger, level, message, details) {
+    if (logger && typeof logger[level] === 'function')
+        logger[level](message, details);
+}

package/harmony-module.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/renbaoshuo/expo-harmony/schemas/expo-module-harmony.json",
+  "title": "Expo Module Harmony metadata",
+  "type": "object",
+  "properties": {
+    "modules": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/arkTsIdentifier" },
+      "uniqueItems": true,
+      "default": [],
+      "description": "ArkTS Expo Module classes exported by the conventional Harmony library."
+    },
+    "rootViewComponents": { "$ref": "#/$defs/arkTsIdentifiers" }
+  },
+  "$defs": {
+    "arkTsIdentifier": {
+      "type": "string",
+      "pattern": "^[A-Za-z_$][A-Za-z0-9_$]*$"
+    },
+    "arkTsIdentifiers": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/arkTsIdentifier" },
+      "uniqueItems": true,
+      "default": []
+    }
+  }
+}

package/index.ts

@@ -0,0 +1,41 @@
+import { linkModulesAsync } from './src/autolinking/link';
+import { canonicalizeAutolinkingArtifacts } from './src/harmony/persistence/canonicalize';
+import { resolveModulesAsync } from './src/autolinking/resolve';
+import { searchModulesAsync } from './src/autolinking/search';
+import { verifyModulesAsync } from './src/autolinking/verify';
+import { normalizeHarmonyModuleMetadata } from './src/metadata/schema';
+
+export {
+  canonicalizeAutolinkingArtifacts,
+  linkModulesAsync,
+  normalizeHarmonyModuleMetadata,
+  resolveModulesAsync,
+  searchModulesAsync,
+  verifyModulesAsync,
+};
+
+export type {
+  BuildType,
+  CanonicalizeAutolinkingArtifactsOptions,
+  CanonicalizedAutolinkingArtifacts,
+  Diagnostic,
+  DiagnosticSource,
+  ExpoMetadata,
+  HostMetadata,
+  HarmonyModuleMetadata,
+  LinkOptions,
+  LinkResult,
+  Logger,
+  Manifest,
+  ModuleDescriptor,
+  ModuleArtifactDescriptor,
+  ModuleSource,
+  Platform,
+  ResolveOptions,
+  RnohMetadata,
+  SearchOptions,
+  SearchRecord,
+  SearchResult,
+  VerificationResult,
+  VerifyOptions,
+} from './src/types';

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@expo-harmony/expo-modules-autolinking",
+  "version": "55.0.25-harmony.1",
+  "description": "HarmonyOS port of expo-modules-autolinking",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-harmony",
+    "harmonyos"
+  ],
+  "author": "Baoshuo <i@baoshuo.ren>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/renbaoshuo/expo-harmony.git",
+    "directory": "packages/expo-modules-autolinking"
+  },
+  "homepage": "https://github.com/renbaoshuo/expo-harmony/tree/master/packages/expo-modules-autolinking#readme",
+  "bugs": "https://github.com/renbaoshuo/expo-harmony/issues",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "rm -rf build && tsc -p tsconfig.json && chmod +x build/bin/expo-harmony-autolinking.js",
+    "prepare": "yarn build",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "require": "./build/index.js",
+      "default": "./build/index.js"
+    },
+    "./harmony-module.schema.json": {
+      "default": "./harmony-module.schema.json"
+    }
+  },
+  "bin": {
+    "expo-harmony-autolinking": "build/bin/expo-harmony-autolinking.js"
+  },
+  "dependencies": {
+    "case": "1.6.3",
+    "commander": "7.2.0",
+    "expo-modules-autolinking": "55.0.25",
+    "json5": "2.2.3"
+  },
+  "devDependencies": {
+    "@react-native-oh/react-native-harmony-cli": "^0.84.1",
+    "@types/node": "18.19.0",
+    "metro": "0.83.3",
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "@react-native-oh/react-native-harmony-cli": "^0.84.1"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-oh/react-native-harmony-cli": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}