appium 3.2.2 → 3.3.1

package/build/lib/extension/extension-config.js

@@ -9,13 +9,13 @@ const support_1 = require("@appium/support");
 const bluebird_1 = __importDefault(require("bluebird"));
 const lodash_1 = __importDefault(require("lodash"));
 const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
 const resolve_from_1 = __importDefault(require("resolve-from"));
 const semver_1 = require("semver");
 const extension_1 = require("../cli/extension");
-const config_1 = require("../config");
-const logger_1 = __importDefault(require("../logger"));
+const build_1 = require("../helpers/build");
+const logger_1 = require("../logger");
 const schema_1 = require("../schema/schema");
-const node_url_1 = require("node:url");
 const DEFAULT_ENTRY_POINT = 'index.js';
 /**
  * "npm" install type
@@ -44,7 +44,6 @@ exports.INSTALL_TYPE_GIT = 'git';
  * Used when automatically detected as a working copy
  */
 exports.INSTALL_TYPE_DEV = 'dev';
-/** @type {Set<InstallType>} */
 exports.INSTALL_TYPES = new Set([
     exports.INSTALL_TYPE_GIT,
     exports.INSTALL_TYPE_GITHUB,
@@ -53,68 +52,72 @@ exports.INSTALL_TYPES = new Set([
     exports.INSTALL_TYPE_DEV,
 ]);
 /**
- * This class is abstract. It should not be instantiated directly.
- *
- * Subclasses should provide the generic parameter to implement.
- * @template {ExtensionType} ExtType
+ * Shared configuration and validation for installed Appium extensions (drivers or plugins).
+ * Subclasses fix the extension kind; do not instantiate this class directly.
  */
 class ExtensionConfig {
-    /**
-     * The type of extension this class is responsible for.
-     * @type {ExtType}
-     */
     extensionType;
-    /**
-     * Manifest data for the extensions of this type.
-     *
-     * This data should _not_ be written to by anything but {@linkcode Manifest}.
-     * @type {Readonly<ExtRecord<ExtType>>}
-     */
-    installedExtensions;
-    /** @type {import('@appium/types').AppiumLogger} */
-    log;
-    /** @type {Manifest} */
     manifest;
-    /**
-     * @type {import('../cli/extension-command').ExtensionList<ExtType>|undefined}
-     */
+    installedExtensions;
     #listDataCache;
-    /**
-     * @protected
-     * @param {ExtType} extensionType - Type of extension
-     * @param {Manifest} manifest - `Manifest` instance
-     */
     constructor(extensionType, manifest) {
         this.extensionType = extensionType;
-        this.installedExtensions = manifest.getExtensionData(extensionType);
         this.manifest = manifest;
+        this.installedExtensions = manifest.getExtensionData(extensionType);
     }
+    /** Path to `extensions.yaml` after the manifest has been read; otherwise undefined. */
     get manifestPath() {
         return this.manifest.manifestPath;
     }
+    /** `APPIUM_HOME` directory this config is tied to. */
     get appiumHome() {
         return this.manifest.appiumHome;
     }
     /**
-     * Returns a list of errors for a given extension.
+     * Type guard: manifest entry includes a `schema` path or inline schema object.
+     *
+     * @param extManifest - Parsed extension metadata
+     */
+    static extDataHasSchema(extManifest) {
+        return lodash_1.default.isString(extManifest?.schema) || lodash_1.default.isObject(extManifest?.schema);
+    }
+    static async _readExtensionSchema(appiumHome, extType, extName, extManifest) {
+        const { pkgName, schema: argSchemaPath } = extManifest;
+        if (!argSchemaPath) {
+            throw new TypeError(`No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`);
+        }
+        let moduleObject;
+        if (lodash_1.default.isString(argSchemaPath)) {
+            const schemaPath = (0, resolve_from_1.default)(appiumHome, node_path_1.default.join(pkgName, argSchemaPath));
+            moduleObject = require(schemaPath);
+        }
+        else {
+            moduleObject = argSchemaPath;
+        }
+        // this sucks. default exports should be destroyed
+        const schema = moduleObject.__esModule ? moduleObject.default : moduleObject;
+        await (0, schema_1.registerSchema)(extType, extName, schema);
+        return schema;
+    }
+    /**
+     * Collects blocking validation issues for one extension (generic fields, type-specific rules, and schema).
      *
-     * @param {ExtName<ExtType>} extName
-     * @param {ExtManifest<ExtType>} extManifest
-     * @returns {ExtManifestProblem[]}
+     * @param extName - Extension key as stored in the manifest
+     * @param extManifest - Manifest entry for that extension
      */
-    getProblems(extName, extManifest) {
+    async getProblems(extName, extManifest) {
         return [
             ...this.getGenericConfigProblems(extManifest, extName),
             ...this.getConfigProblems(extManifest, extName),
-            ...this.getSchemaProblems(extManifest, extName),
+            ...(await this.getSchemaProblems(extManifest, extName)),
         ];
     }
     /**
-     * Returns a list of warnings for a given extension.
+     * Collects non-fatal issues for one extension (e.g. manifest quirks, peer dependency mismatches).
+     * Warnings do not by themselves prevent loading.
      *
-     * @param {ExtName<ExtType>} extName
-     * @param {ExtManifest<ExtType>} extManifest
-     * @returns {Promise<string[]>}
+     * @param extName - Extension key as stored in the manifest
+     * @param extManifest - Manifest entry for that extension
      */
     async getWarnings(extName, extManifest) {
         const [genericConfigWarnings, configWarnings] = await bluebird_1.default.all([
@@ -124,26 +127,12 @@ class ExtensionConfig {
         return [...genericConfigWarnings, ...configWarnings];
     }
     /**
-     * Returns a list of extension-type-specific issues. To be implemented by subclasses.
-     * @abstract
-     * @param {ExtManifest<ExtType>} extManifest
-     * @param {ExtName<ExtType>} extName
-     * @returns {Promise<string[]>}
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async getConfigWarnings(extManifest, extName) {
-        return [];
-    }
-    /**
+     * Turns per-extension errors and warnings into human-readable log lines for console output.
      *
-     * @param {Map<ExtName<ExtType>,ExtManifestProblem[]>} [errorMap]
-     * @param {Map<ExtName<ExtType>,string[]>} [warningMap]
+     * @param errorMap - Extension name to list of blocking problems
+     * @param warningMap - Extension name to list of warning strings
      */
     getValidationResultSummaries(errorMap = new Map(), warningMap = new Map()) {
-        /**
-         * Array of computed strings
-         * @type {string[]}
-         */
         const errorSummaries = [];
         for (const [extName, problems] of errorMap.entries()) {
             if (lodash_1.default.isEmpty(problems)) {
@@ -155,7 +144,6 @@ class ExtensionConfig {
                 errorSummaries.push(`  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`);
             }
         }
-        /** @type {string[]} */
         const warningSummaries = [];
         for (const [extName, warnings] of warningMap.entries()) {
             if (lodash_1.default.isEmpty(warnings)) {
@@ -171,26 +159,116 @@ class ExtensionConfig {
         return { errorSummaries, warningSummaries };
     }
     /**
-     * Checks extensions for problems.  To be called by subclasses' `validate` method.
+     * Records a new installed extension in the manifest and optionally persists immediately.
      *
-     * Errors and warnings will be displayed to the user.
+     * @param extName - Manifest key for the extension
+     * @param extManifest - Full manifest payload
      *
-     * This method mutates `exts`.
+     * Pass `{ write: false }` to defer flushing until a later manifest write.
+     */
+    async addExtension(extName, extManifest, { write = true } = {}) {
+        this.manifest.setExtension(this.extensionType, extName, extManifest);
+        if (write) {
+            await this.manifest.write();
+        }
+    }
+    /**
+     * Merges new metadata into an existing extension entry and optionally writes the manifest.
+     *
+     * @param extName - Installed extension to update
+     * @param extManifest - Fields to merge over the current entry
      *
-     * @protected
-     * @param {ExtRecord<ExtType>} exts - Lookup of extension names to {@linkcode ExtManifest} objects
-     * @returns {Promise<ExtRecord<ExtType>>} The same lookup, but picking only error-free extensions
+     * Pass `{ write: false }` to defer flushing until a later manifest write.
+     */
+    async updateExtension(extName, extManifest, { write = true } = {}) {
+        const existing = this.installedExtensions[extName];
+        this.manifest.setExtension(this.extensionType, extName, {
+            ...existing,
+            ...extManifest,
+        });
+        if (write) {
+            await this.manifest.write();
+        }
+    }
+    /**
+     * Drops an extension from the manifest and optionally persists immediately.
+     *
+     * @param extName - Installed extension to remove
+     *
+     * Pass `{ write: false }` to defer flushing until a later manifest write.
+     */
+    async removeExtension(extName, { write = true } = {}) {
+        this.manifest.deleteExtension(this.extensionType, extName);
+        if (write) {
+            await this.manifest.write();
+        }
+    }
+    /**
+     * Logs installed extensions to the console. Subclasses may use `activeNames` to annotate active plugins.
+     */
+    print(_activeNames) {
+        void _activeNames;
+        if (lodash_1.default.isEmpty(this.installedExtensions)) {
+            logger_1.log.info(`No ${this.extensionType}s have been installed in ${this.appiumHome}. Use the "appium ${this.extensionType}" ` +
+                'command to install the one(s) you want to use.');
+            return;
+        }
+        logger_1.log.info(`Available ${this.extensionType}s:`);
+        for (const [extName, extManifest] of lodash_1.default.toPairs(this.installedExtensions)) {
+            logger_1.log.info(`  - ${this.extensionDesc(extName, extManifest)}`);
+        }
+    }
+    /**
+     * Root directory of an installed extension, preferring `installPath` and falling back to `node_modules/<pkgName>`.
+     *
+     * @param extName - Installed extension key
+     */
+    getInstallPath(extName) {
+        return (this.installedExtensions[extName]?.installPath ??
+            node_path_1.default.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName));
+    }
+    /**
+     * Dynamically imports the extension entry point and returns the exported main class constructor.
+     *
+     * @param extName - Installed extension to load
+     */
+    async requireAsync(extName) {
+        const [reqPath, mainClass] = await this._resolveExtension(extName);
+        logger_1.log.debug(`Requiring ${this.extensionType} at ${reqPath}`);
+        // https://github.com/nodejs/node/issues/31710
+        const importPath = support_1.system.isWindows() ? (0, node_url_1.pathToFileURL)(reqPath).href : reqPath;
+        const mod = (await import(importPath));
+        const MainClass = mod[mainClass];
+        if (!MainClass) {
+            throw new ReferenceError(`Could not find a class named "${mainClass}" exported by ${this.extensionType} "${extName}"`);
+        }
+        return MainClass;
+    }
+    /** Whether the manifest lists an extension under the given name. */
+    isInstalled(extName) {
+        return extName in this.installedExtensions;
+    }
+    /**
+     * Loads the extension’s config schema from disk or inline JSON and registers it for CLI/config validation.
+     *
+     * @param extName - Extension key
+     * @param extManifest - Manifest entry that includes `schema`
+     */
+    async readExtensionSchema(extName, extManifest) {
+        return await ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extManifest);
+    }
+    /** Optional async warnings for this extension kind; override in subclasses when needed. */
+    async getConfigWarnings(_extManifest, _extName) {
+        void _extManifest;
+        void _extName;
+        return [];
+    }
+    /**
+     * Validates all entries in `exts`, logs summaries, and removes keys that have blocking errors.
+     * Intended for subclasses’ `validate` implementation.
      */
     async _validate(exts) {
-        /**
-         * Lookup of extension names to {@linkcode ExtManifestProblem ExtManifestProblems}
-         * @type {Map<ExtName<ExtType>,ExtManifestProblem[]>}
-         */
         const errorMap = new Map();
-        /**
-         * Lookup of extension names to warnings.
-         * @type {Map<ExtName<ExtType>,string[]>}
-         */
         const warningMap = new Map();
         for (const [extName, extManifest] of lodash_1.default.toPairs(exts)) {
             const [errors, warnings] = await bluebird_1.default.all([
@@ -205,47 +283,35 @@ class ExtensionConfig {
         }
         const { errorSummaries, warningSummaries } = this.getValidationResultSummaries(errorMap, warningMap);
         if (!lodash_1.default.isEmpty(errorSummaries)) {
-            logger_1.default.error(`Appium encountered ${support_1.util.pluralize('error', errorMap.size, true)} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`);
+            logger_1.log.error(`Appium encountered ${support_1.util.pluralize('error', errorMap.size, true)} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`);
             for (const summary of errorSummaries) {
-                logger_1.default.error(summary);
+                logger_1.log.error(summary);
             }
         }
         else if (!lodash_1.default.isEmpty(warningSummaries)) {
             // only display warnings if there are no errors!
-            logger_1.default.warn(`Appium encountered ${support_1.util.pluralize('warning', warningMap.size, true)} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`);
+            logger_1.log.warn(`Appium encountered ${support_1.util.pluralize('warning', warningMap.size, true)} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`);
             for (const summary of warningSummaries) {
-                logger_1.default.warn(summary);
+                logger_1.log.warn(summary);
             }
         }
         return exts;
     }
     /**
-     * Retrieves listing data for extensions via command class.
-     *
-     * This is an expensive operation, so the result is cached.  Currently, there is no
-     * use case for invalidating the cache.
-     * @protected
-     * @returns {Promise<import('../cli/extension-command').ExtensionList<ExtType>>}
+     * Fetches `appium driver|plugin list`-style data via the CLI command class; result is cached.
      */
     async getListData() {
         if (this.#listDataCache) {
             return this.#listDataCache;
         }
-        const CommandClass = /** @type {ExtCommand<ExtType>} */ (extension_1.commandClasses[this.extensionType]);
+        const CommandClass = extension_1.commandClasses[this.extensionType];
         const cmd = new CommandClass({ config: this, json: true });
         const listData = await cmd.list({ showInstalled: true, showUpdates: true });
         this.#listDataCache = listData;
         return listData;
     }
     /**
-     * Returns a list of warnings for a particular extension.
-     *
-     * By definition, a non-empty list of warnings does _not_ imply the extension cannot be loaded,
-     * but it may not work as expected or otherwise throw an exception at runtime.
-     *
-     * @param {ExtManifest<ExtType>} extManifest
-     * @param {ExtName<ExtType>} extName
-     * @returns {Promise<string[]>}
+     * Warnings about manifest install fields and Appium peer dependency compatibility for one extension.
      */
     async getGenericConfigWarnings(extManifest, extName) {
         const { appiumVersion, installSpec, installType, pkgName } = extManifest;
@@ -265,16 +331,10 @@ class ExtensionConfig {
                 `this may cause upgrades done via the \`appium\` CLI tool to fail. Please reinstall with \`appium ${this.extensionType} uninstall ` +
                 `${extName}\` and \`appium ${this.extensionType} install ${extName}\` to attempt a fix.`);
         }
-        /**
-         * Helps concatenate warning messages related to peer dependencies
-         * @param {string} reason
-         * @returns string
-         */
-        const createPeerWarning = (reason) => `${extTypeText} "${extName}" (package \`${pkgName}\`) may be incompatible with the current version of Appium (v${config_1.APPIUM_VER}) due to ${reason}`;
-        if (lodash_1.default.isString(appiumVersion) && !(0, semver_1.satisfies)(config_1.APPIUM_VER, appiumVersion)) {
+        const createPeerWarning = (reason) => `${extTypeText} "${extName}" (package \`${pkgName}\`) may be incompatible with the current version of Appium (v${build_1.APPIUM_VER}) due to ${reason}`;
+        if (lodash_1.default.isString(appiumVersion) && !(0, semver_1.satisfies)(build_1.APPIUM_VER, appiumVersion)) {
             const listData = await this.getListData();
-            const extListData = 
-            /** @type {import('../cli/extension-command').ExtensionListData<ExtType>} */ (listData[extName]);
+            const extListData = listData[extName];
             if (extListData?.installed) {
                 const { updateVersion, upToDate } = extListData;
                 if (!upToDate && updateVersion) {
@@ -287,35 +347,27 @@ class ExtensionConfig {
         }
         else if (!lodash_1.default.isString(appiumVersion)) {
             const listData = await this.getListData();
-            const extListData = 
-            /** @type {import('../cli/extension-command').InstalledExtensionListData<ExtType>} */ (listData[extName]);
+            const extListData = listData[extName];
             if (!extListData?.upToDate && extListData?.updateVersion) {
                 warnings.push(createPeerWarning(`an invalid or missing peer dependency on Appium. A newer version of \`${pkgName}\` is available; ` +
                     `please attempt to upgrade "${extName}" to v${extListData.updateVersion} or newer.`));
             }
             else {
                 warnings.push(createPeerWarning(`an invalid or missing peer dependency on Appium. ` +
-                    `Please ask the developer of \`${pkgName}\` to add a peer dependency on \`^appium@${config_1.APPIUM_VER}\`.`));
+                    `Please ask the developer of \`${pkgName}\` to add a peer dependency on \`^appium@${build_1.APPIUM_VER}\`.`));
             }
         }
         return warnings;
     }
-    /**
-     * Returns list of unrecoverable errors (if any) for the given extension _if_ it has a `schema` property.
-     *
-     * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)
-     * @param {ExtName<ExtType>} extName - Extension name (from manifest)
-     * @returns {ExtManifestProblem[]}
-     */
-    getSchemaProblems(extManifest, extName) {
-        /** @type {ExtManifestProblem[]} */
+    /** Validates and registers extension CLI/config schema when the manifest defines a `schema` field. */
+    async getSchemaProblems(extManifest, extName) {
         const problems = [];
         const { schema: argSchemaPath } = extManifest;
         if (ExtensionConfig.extDataHasSchema(extManifest)) {
             if (lodash_1.default.isString(argSchemaPath)) {
                 if ((0, schema_1.isAllowedSchemaFileExtension)(argSchemaPath)) {
                     try {
-                        this.readExtensionSchema(extName, extManifest);
+                        await this.readExtensionSchema(extName, extManifest);
                     }
                     catch (err) {
                         problems.push({
@@ -335,7 +387,7 @@ class ExtensionConfig {
             }
             else if (lodash_1.default.isPlainObject(argSchemaPath)) {
                 try {
-                    this.readExtensionSchema(extName, extManifest);
+                    await this.readExtensionSchema(extName, extManifest);
                 }
                 catch (err) {
                     problems.push({
@@ -353,14 +405,9 @@ class ExtensionConfig {
         }
         return problems;
     }
-    /**
-     * Return a list of generic unrecoverable errors for the given extension
-     * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)
-     * @param {ExtName<ExtType>} extName - Extension name (from manifest)
-     * @returns {ExtManifestProblem[]}
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    /** Blocking issues for required manifest fields shared by all extensions (version, package name, main class). */
     getGenericConfigProblems(extManifest, extName) {
+        void extName;
         const { version, pkgName, mainClass } = extManifest;
         const problems = [];
         if (!lodash_1.default.isString(version)) {
@@ -383,100 +430,12 @@ class ExtensionConfig {
         }
         return problems;
     }
-    /**
-     * @abstract
-     * @param {ExtManifest<ExtType>} extManifest
-     * @param {ExtName<ExtType>} extName
-     * @returns {ExtManifestProblem[]}
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getConfigProblems(extManifest, extName) {
-        // should override this method if special validation is necessary for this extension type
+    /** Driver- or plugin-specific blocking validation; override in subclasses when needed. */
+    getConfigProblems(_extManifest, _extName) {
+        void _extManifest;
+        void _extName;
         return [];
     }
-    /**
-     * @param {string} extName
-     * @param {ExtManifest<ExtType>} extManifest
-     * @param {ExtensionConfigMutationOpts} opts
-     * @returns {Promise<void>}
-     */
-    async addExtension(extName, extManifest, { write = true } = {}) {
-        this.manifest.setExtension(this.extensionType, extName, extManifest);
-        if (write) {
-            await this.manifest.write();
-        }
-    }
-    /**
-     * @param {ExtName<ExtType>} extName
-     * @param {ExtManifest<ExtType>} extManifest
-     * @param {ExtensionConfigMutationOpts} opts
-     * @returns {Promise<void>}
-     */
-    async updateExtension(extName, extManifest, { write = true } = {}) {
-        this.manifest.setExtension(this.extensionType, extName, {
-            ...this.installedExtensions[extName],
-            ...extManifest,
-        });
-        if (write) {
-            await this.manifest.write();
-        }
-    }
-    /**
-     * Remove an extension from the list of installed extensions, and optionally avoid a write to the manifest file.
-     *
-     * @param {ExtName<ExtType>} extName
-     * @param {ExtensionConfigMutationOpts} opts
-     * @returns {Promise<void>}
-     */
-    async removeExtension(extName, { write = true } = {}) {
-        this.manifest.deleteExtension(this.extensionType, extName);
-        if (write) {
-            await this.manifest.write();
-        }
-    }
-    /**
-     * @param {ExtName<ExtType>[]} [activeNames]
-     * @returns {void}
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    print(activeNames) {
-        if (lodash_1.default.isEmpty(this.installedExtensions)) {
-            logger_1.default.info(`No ${this.extensionType}s have been installed in ${this.appiumHome}. Use the "appium ${this.extensionType}" ` +
-                'command to install the one(s) you want to use.');
-            return;
-        }
-        logger_1.default.info(`Available ${this.extensionType}s:`);
-        for (const [extName, extManifest] of /** @type {[string, ExtManifest<ExtType>][]} */ (lodash_1.default.toPairs(this.installedExtensions))) {
-            logger_1.default.info(`  - ${this.extensionDesc(extName, extManifest)}`);
-        }
-    }
-    /**
-     * Returns a string describing the extension. Subclasses must implement.
-     * @param {ExtName<ExtType>} extName - Extension name
-     * @param {ExtManifest<ExtType>} extManifest - Extension data
-     * @returns {string}
-     * @abstract
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    extensionDesc(extName, extManifest) {
-        throw new Error('This must be implemented in a subclass');
-    }
-    /**
-     * Returns--with reasonable accuracy--the path on disk to the extension.
-     *
-     * If `installPath` is present in the manifest, then it is used; otherwise we just guess.
-     * @param {keyof typeof this.installedExtensions} extName
-     * @returns {string}
-     */
-    getInstallPath(extName) {
-        return (this.installedExtensions[extName]?.installPath ??
-            node_path_1.default.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName));
-    }
-    /**
-     *
-     * @param {ExtName<ExtType>} extName
-     * @returns {Promise<[string, string]>}
-     */
     async _resolveExtension(extName) {
         const { mainClass } = this.installedExtensions[extName];
         const moduleRoot = this.getInstallPath(extName);
@@ -488,7 +447,6 @@ class ExtensionConfig {
         catch (e) {
             throw new ReferenceError(`Could not read the ${this.extensionType} manifest at ${packageJsonPath}: ${e.message}`);
         }
-        /** @type {string | undefined} */
         let entryPointRelativePath;
         try {
             if (extensionManifest.type === 'module' && extensionManifest.exports) {
@@ -499,97 +457,24 @@ class ExtensionConfig {
         catch (e) {
             throw new ReferenceError(`Could not find the ${this.extensionType} installed at ${moduleRoot}: ${e.message}`);
         }
-        const entryPointFullPath = node_path_1.default.resolve(moduleRoot, /** @type {string} */ (entryPointRelativePath));
+        const entryPointFullPath = node_path_1.default.resolve(moduleRoot, entryPointRelativePath);
         if (!await support_1.fs.exists(entryPointFullPath)) {
             throw new ReferenceError(`Cannot find a valid ${this.extensionType} main entry point in '${packageJsonPath}'. ` +
                 `Assumed entry point: '${entryPointFullPath}'`);
         }
         // note: this will only reload the entry point
         if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[entryPointFullPath]) {
-            logger_1.default.debug(`Removing ${entryPointFullPath} from require cache`);
+            logger_1.log.debug(`Removing ${entryPointFullPath} from require cache`);
             delete require.cache[entryPointFullPath];
         }
         return [entryPointFullPath, mainClass];
     }
-    /**
-     * Loads extension asynchronously and returns its main class (constructor)
-     *
-     * @param {ExtName<ExtType>} extName
-     * @returns {Promise<ExtClass<ExtType>>}
-     */
-    async requireAsync(extName) {
-        const [reqPath, mainClass] = await this._resolveExtension(extName);
-        logger_1.default.debug(`Requiring ${this.extensionType} at ${reqPath}`);
-        // https://github.com/nodejs/node/issues/31710
-        const importPath = support_1.system.isWindows() ? (0, node_url_1.pathToFileURL)(reqPath).href : reqPath;
-        const MainClass = (await import(importPath))[mainClass];
-        if (!MainClass) {
-            throw new ReferenceError(`Could not find a class named "${mainClass}" exported by ${this.extensionType} "${extName}"`);
-        }
-        return MainClass;
-    }
-    /**
-     * @param {string} extName
-     * @returns {boolean}
-     */
-    isInstalled(extName) {
-        return extName in this.installedExtensions;
-    }
-    /**
-     * Intended to be called by corresponding instance methods of subclass.
-     * @private
-     * @template {ExtensionType} ExtType
-     * @param {string} appiumHome
-     * @param {ExtType} extType
-     * @param {ExtName<ExtType>} extName - Extension name (unique to its type)
-     * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension config
-     * @returns {import('ajv').SchemaObject|undefined}
-     */
-    static _readExtensionSchema(appiumHome, extType, extName, extManifest) {
-        const { pkgName, schema: argSchemaPath } = extManifest;
-        if (!argSchemaPath) {
-            throw new TypeError(`No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`);
-        }
-        let moduleObject;
-        if (lodash_1.default.isString(argSchemaPath)) {
-            const schemaPath = (0, resolve_from_1.default)(appiumHome, node_path_1.default.join(pkgName, argSchemaPath));
-            moduleObject = require(schemaPath);
-        }
-        else {
-            moduleObject = argSchemaPath;
-        }
-        // this sucks. default exports should be destroyed
-        const schema = moduleObject.__esModule ? moduleObject.default : moduleObject;
-        (0, schema_1.registerSchema)(extType, extName, schema);
-        return schema;
-    }
-    /**
-     * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.
-     * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.
-     * @template {ExtensionType} ExtType
-     * @param {ExtManifest<ExtType>} extManifest
-     * @returns {extManifest is ExtManifestWithSchema<ExtType>}
-     */
-    static extDataHasSchema(extManifest) {
-        return lodash_1.default.isString(extManifest?.schema) || lodash_1.default.isObject(extManifest?.schema);
-    }
-    /**
-     * If an extension provides a schema, this will load the schema and attempt to
-     * register it with the schema registrar.
-     * @param {ExtName<ExtType>} extName - Name of extension
-     * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension data
-     * @returns {import('ajv').SchemaObject|undefined}
-     */
-    readExtensionSchema(extName, extManifest) {
-        return ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extManifest);
-    }
 }
 exports.ExtensionConfig = ExtensionConfig;
 /**
- * https://nodejs.org/api/packages.html#package-entry-points
+ * Resolves a package `exports` field (string, `"."`, or `"import"`) to a relative entry path for ESM packages.
  *
- * @param {any} exportsValue
- * @returns {string | undefined}
+ * @param exportsValue - `package.json` `exports` value or nested fragment
  */
 function resolveEsmEntryPoint(exportsValue) {
     if (lodash_1.default.isString(exportsValue) && exportsValue) {
@@ -598,58 +483,11 @@ function resolveEsmEntryPoint(exportsValue) {
     if (!lodash_1.default.isPlainObject(exportsValue)) {
         return;
     }
+    const obj = exportsValue;
     for (const key of ['.', 'import']) {
-        if (exportsValue[key]) {
-            return resolveEsmEntryPoint(exportsValue[key]);
+        if (obj[key]) {
+            return resolveEsmEntryPoint(obj[key]);
         }
     }
 }
-/**
- * An issue with the {@linkcode ExtManifest} for a particular extension.
- *
- * The existance of such an object implies that the extension cannot be loaded.
- * @typedef ExtManifestProblem
- * @property {string} err - Error message
- * @property {any} val - Associated value
- */
-/**
- * An optional logging function provided to an {@link ExtensionConfig} subclass.
- * @callback ExtensionLogFn
- * @param {...any} args
- * @returns {void}
- */
-/**
- * @typedef {import('@appium/types').ExtensionType} ExtensionType
- * @typedef {import('./manifest').Manifest} Manifest
- * @typedef {import('appium/types').InstallType} InstallType
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('appium/types').ExtManifest<ExtType>} ExtManifest
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {ExtManifest<ExtType> & {schema: NonNullable<ExtManifest<ExtType>['schema']>}} ExtManifestWithSchema
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('appium/types').ExtName<ExtType>} ExtName
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('appium/types').ExtClass<ExtType>} ExtClass
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('appium/types').ExtRecord<ExtType>} ExtRecord
- */
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('../cli/extension').ExtCommand<ExtType>} ExtCommand
- */
-/**
- * Options for various methods in {@link ExtensionConfig}
- * @typedef ExtensionConfigMutationOpts
- * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation
- */
 //# sourceMappingURL=extension-config.js.map