appium 3.2.2 → 3.3.1

package/lib/schema/schema.ts

@@ -0,0 +1,448 @@
+import Ajv, {type ErrorObject, type SchemaObject, type ValidateFunction} from 'ajv';
+import addFormats from 'ajv-formats';
+import _ from 'lodash';
+import path from 'node:path';
+import {AppiumConfigJsonSchema} from '@appium/schema';
+import type {ExtensionType} from '@appium/types';
+import {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
+import {APPIUM_CONFIG_SCHEMA_ID, ArgSpec, SERVER_PROP_NAME} from './arg-spec';
+import {keywords} from './keywords';
+
+type StrictSchemaObject = SchemaObject & {additionalProperties: false};
+type FlattenedSchema = {schema: SchemaObject; argSpec: ArgSpec}[];
+type ArgSpecDefaultValue = ArgSpec['defaultValue'];
+type NestedArgSpecDefaultValue = Record<string, Record<string, ArgSpecDefaultValue>>;
+type DefaultValues<Flattened extends boolean | undefined> = Record<
+  string,
+  Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue
+>;
+type AllowedSchemaExtension = '.json' | '.js' | '.cjs';
+
+/**
+ * Key/value pairs go in... but they don't come out.
+ */
+export class RoachHotelMap<K, V> extends Map<K, V> {
+  override set(key: K, value: V): this {
+    if (this.has(key)) {
+      throw new Error(`${String(key)} is already set`);
+    }
+    return super.set(key, value);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  override delete(_key: K): boolean {
+    return false;
+  }
+
+  override clear(): void {
+    throw new Error(`Cannot clear RoachHotelMap`);
+  }
+}
+
+export const ALLOWED_SCHEMA_EXTENSIONS = Object.freeze(
+  new Set<AllowedSchemaExtension>(['.json', '.js', '.cjs'])
+);
+
+const SCHEMA_KEY = '$schema';
+
+class AppiumSchema {
+  static #instance: AppiumSchema;
+  #argSpecs = new RoachHotelMap<string, ArgSpec>();
+  #registeredSchemas: Record<ExtensionType, Map<string, SchemaObject>> = {
+    [DRIVER_TYPE]: new Map(),
+    [PLUGIN_TYPE]: new Map(),
+  };
+  #ajv: Ajv;
+  #finalizedSchemas: Record<string, StrictSchemaObject> | null = null;
+
+  private constructor() {
+    this.#ajv = AppiumSchema._instantiateAjv();
+  }
+
+  /**
+   * Returns a singleton instance.
+   */
+  static create(): AppiumSchema {
+    if (!AppiumSchema.#instance) {
+      const instance = new AppiumSchema();
+      AppiumSchema.#instance = instance;
+      _.bindAll(instance, [
+        'finalize',
+        'flatten',
+        'getAllArgSpecs',
+        'getArgSpec',
+        'getDefaults',
+        'getDefaultsForExtension',
+        'getSchema',
+        'hasArgSpec',
+        'isFinalized',
+        'registerSchema',
+        'hasRegisteredSchema',
+        'reset',
+        'validate',
+      ]);
+    }
+    return AppiumSchema.#instance;
+  }
+
+  /**
+   * Returns `true` if filename extension is an allowed schema extension.
+   */
+  static isAllowedSchemaFileExtension(filename: string): boolean {
+    return ALLOWED_SCHEMA_EXTENSIONS.has(path.extname(filename) as AllowedSchemaExtension);
+  }
+
+  /**
+   * Returns `true` if schema is a plain object and not async.
+   */
+  static isSupportedSchemaType(schema: any): schema is SchemaObject {
+    return _.isPlainObject(schema) && (schema as any).$async !== true;
+  }
+
+  /**
+   * Configures and creates an Ajv instance.
+   */
+  private static _instantiateAjv(): Ajv {
+    const ajv = addFormats(
+      new Ajv({
+        // without this not much validation actually happens
+        allErrors: true,
+      })
+    );
+    _.forEach(keywords, (keyword) => {
+      ajv.addKeyword(keyword);
+    });
+    return ajv;
+  }
+
+  /**
+   * Returns `true` if a schema has been registered for extension type/name.
+   */
+  hasRegisteredSchema(extType: ExtensionType, extName: string): boolean {
+    return this.#registeredSchemas[extType].has(extName);
+  }
+
+  /**
+   * Returns `true` if this instance has been finalized.
+   */
+  isFinalized(): boolean {
+    return Boolean(this.#finalizedSchemas);
+  }
+
+  /**
+   * Returns map of known argument specs.
+   */
+  getAllArgSpecs(): ReadonlyMap<string, ArgSpec> {
+    return this.#argSpecs;
+  }
+
+  /**
+   * Finalizes all registered schemas into Ajv and generates arg-spec lookups.
+   */
+  async finalize(): Promise<Readonly<Record<string, StrictSchemaObject>>> {
+    if (this.isFinalized()) {
+      return this.#finalizedSchemas as Record<string, StrictSchemaObject>;
+    }
+
+    const ajv = this.#ajv;
+    const baseSchema = _.cloneDeep(AppiumConfigJsonSchema) as any;
+
+    const addArgSpecs = (
+      schema: Record<string, any>,
+      extType?: ExtensionType,
+      extName?: string
+    ): void => {
+      for (const [propName, propSchema] of Object.entries(schema)) {
+        const argSpec = ArgSpec.create(propName, {
+          dest: (propSchema as any).appiumCliDest,
+          defaultValue: (propSchema as any).default,
+          extType,
+          extName,
+        });
+        this.#argSpecs.set(argSpec.arg, argSpec);
+      }
+    };
+
+    addArgSpecs(_.omit(baseSchema.properties.server.properties, [DRIVER_TYPE, PLUGIN_TYPE]));
+
+    const finalizedSchemas: Record<string, StrictSchemaObject> = {};
+
+    for (const [extType, extensionSchemas] of Object.entries(this.#registeredSchemas) as Array<
+      [ExtensionType, Map<string, SchemaObject>]
+    >) {
+      for (const [extName, schema] of extensionSchemas.entries()) {
+        const $ref = ArgSpec.toSchemaBaseRef(extType, extName);
+        (schema as any).$id = $ref;
+        (schema as any).additionalProperties = false;
+        baseSchema.properties.server.properties[extType].properties[extName] = {$ref, $comment: extName};
+        await ajv.validateSchema(schema, true);
+        addArgSpecs((schema as any).properties, extType, extName);
+        ajv.addSchema(schema, $ref);
+        finalizedSchemas[$ref] = schema as StrictSchemaObject;
+      }
+    }
+
+    const finalSchema = baseSchema as StrictSchemaObject;
+
+    ajv.addSchema(finalSchema, APPIUM_CONFIG_SCHEMA_ID);
+    finalizedSchemas[APPIUM_CONFIG_SCHEMA_ID] = finalSchema;
+    await ajv.validateSchema(finalSchema, true);
+    this.#finalizedSchemas = finalizedSchemas;
+    return Object.freeze(finalizedSchemas);
+  }
+
+  /**
+   * Resets this instance to initial state.
+   */
+  reset(): void {
+    for (const schemaId of Object.keys(this.#finalizedSchemas ?? {})) {
+      this.#ajv.removeSchema(schemaId);
+    }
+    this.#argSpecs = new RoachHotelMap();
+    this.#registeredSchemas = {[DRIVER_TYPE]: new Map(), [PLUGIN_TYPE]: new Map()};
+    this.#finalizedSchemas = null;
+    this.#ajv = AppiumSchema._instantiateAjv();
+  }
+
+  /**
+   * Registers an extension schema.
+   */
+  async registerSchema(extType: ExtensionType, extName: string, schema: SchemaObject): Promise<void> {
+    if (!(extType && extName) || _.isUndefined(schema)) {
+      throw new TypeError('Expected extension type, extension name, and a defined schema');
+    }
+    if (!AppiumSchema.isSupportedSchemaType(schema)) {
+      throw new SchemaUnsupportedSchemaError(schema, extType, extName);
+    }
+    const normalizedExtName = _.kebabCase(extName);
+    if (this.hasRegisteredSchema(extType, normalizedExtName)) {
+      if (_.isEqual(this.#registeredSchemas[extType].get(normalizedExtName), schema)) {
+        return;
+      }
+      throw new SchemaNameConflictError(extType, extName);
+    }
+    await this.#ajv.validateSchema(schema, true);
+    this.#registeredSchemas[extType].set(normalizedExtName, schema);
+  }
+
+  /**
+   * Returns an `ArgSpec` for argument name/ext context, if present.
+   */
+  getArgSpec(name: string, extType?: ExtensionType, extName?: string): ArgSpec | undefined {
+    return this.#argSpecs.get(ArgSpec.toArg(name, extType, extName));
+  }
+
+  /**
+   * Returns `true` if an `ArgSpec` exists for argument name/ext context.
+   */
+  hasArgSpec(name: string, extType?: ExtensionType, extName?: string): boolean {
+    return this.#argSpecs.has(ArgSpec.toArg(name, extType, extName));
+  }
+
+  /**
+   * Returns default values for all args, flattened or nested.
+   */
+  getDefaults<Flattened extends boolean | undefined = true>(
+    flatten = true as Flattened
+  ): DefaultValues<Flattened> {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    const reducer = flatten
+      ? (defaults: any, {defaultValue, dest}: ArgSpec) => {
+          if (!_.isUndefined(defaultValue)) {
+            defaults[dest] = defaultValue;
+          }
+          return defaults;
+        }
+      : (defaults: any, {defaultValue, dest}: ArgSpec) => {
+          if (!_.isUndefined(defaultValue)) {
+            _.set(defaults, dest, defaultValue);
+          }
+          return defaults;
+        };
+
+    const retval = {} as DefaultValues<Flattened>;
+    return [...this.#argSpecs.values()].reduce(reducer, retval);
+  }
+
+  /**
+   * Returns flattened defaults for a specific extension.
+   */
+  getDefaultsForExtension(
+    extType: ExtensionType,
+    extName: string
+  ): Record<string, ArgSpecDefaultValue> {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+    const specs = [...this.#argSpecs.values()].filter(
+      (spec) => spec.extType === extType && spec.extName === extName
+    );
+    return specs.reduce((defaults, {defaultValue, rawDest}) => {
+      if (!_.isUndefined(defaultValue)) {
+        defaults[rawDest] = defaultValue;
+      }
+      return defaults;
+    }, {} as Record<string, ArgSpecDefaultValue>);
+  }
+
+  /**
+   * Flattens finalized schemas into schema + argSpec tuples.
+   */
+  flatten(): FlattenedSchema {
+    const schema = this.getSchema() as any;
+    const stack: {properties: Record<string, any>; prefix: string[]}[] = [
+      {properties: schema.properties, prefix: []},
+    ];
+    const flattened: FlattenedSchema = [];
+
+    for (const {properties, prefix} of stack) {
+      const pairs = _.toPairs(properties);
+      for (const [key, value] of pairs) {
+        if (key === SCHEMA_KEY) {
+          continue;
+        }
+        const {properties, $ref} = value as any;
+        if (properties) {
+          stack.push({properties, prefix: key === SERVER_PROP_NAME ? [] : [...prefix, key]});
+        } else if ($ref) {
+          let refSchema: any;
+          try {
+            refSchema = this.getSchema($ref);
+          } catch {
+            throw new SchemaUnknownSchemaError($ref);
+          }
+          const {normalizedExtName} = ArgSpec.extensionInfoFromRootSchemaId($ref);
+          if (!normalizedExtName) {
+            throw new ReferenceError(
+              `Could not determine extension name from schema ID ${$ref}. This is a bug.`
+            );
+          }
+          stack.push({properties: refSchema.properties, prefix: [...prefix, key, normalizedExtName]});
+        } else if (key !== DRIVER_TYPE && key !== PLUGIN_TYPE) {
+          const [extType, extName] = prefix;
+          const argSpec = this.getArgSpec(key, extType as ExtensionType, extName);
+          if (!argSpec) {
+            throw new ReferenceError(
+              `Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`
+            );
+          }
+          flattened.push({schema: _.cloneDeep(value as SchemaObject), argSpec});
+        }
+      }
+    }
+    return flattened;
+  }
+
+  /**
+   * Returns schema by ID (default: base Appium schema).
+   */
+  getSchema(ref = APPIUM_CONFIG_SCHEMA_ID): SchemaObject {
+    return this._getValidator(ref).schema as SchemaObject;
+  }
+
+  /**
+   * Validates a value against schema by ID/reference.
+   */
+  validate(value: any, ref = APPIUM_CONFIG_SCHEMA_ID): ErrorObject[] {
+    const validator = this._getValidator(ref);
+    return !validator(value) && _.isArray(validator.errors) ? [...validator.errors] : [];
+  }
+
+  /**
+   * Retrieves schema validator function from Ajv.
+   */
+  private _getValidator(id = APPIUM_CONFIG_SCHEMA_ID): ValidateFunction {
+    const validator = this.#ajv.getSchema(id);
+    if (!validator) {
+      if (id === APPIUM_CONFIG_SCHEMA_ID) {
+        throw new SchemaFinalizationError();
+      }
+      throw new SchemaUnknownSchemaError(id);
+    }
+    return validator;
+  }
+}
+
+export class SchemaFinalizationError extends Error {
+  readonly code = 'APPIUMERR_SCHEMA_FINALIZATION' as const;
+  constructor() {
+    super('Schema not yet finalized; `finalize()` must be called first.');
+  }
+}
+
+/**
+ * Thrown when a unique extension schema name conflicts with an existing one.
+ */
+export class SchemaNameConflictError extends Error {
+  readonly code = 'APPIUMERR_SCHEMA_NAME_CONFLICT' as const;
+  readonly data: Readonly<{extType: ExtensionType; extName: string}>;
+  constructor(extType: ExtensionType, extName: string) {
+    super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
+    this.data = {extType, extName};
+  }
+}
+
+/**
+ * Thrown when requested schema ID is unknown to Ajv.
+ */
+export class SchemaUnknownSchemaError extends ReferenceError {
+  readonly code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA' as const;
+  readonly data: Readonly<{schemaId: string}>;
+  constructor(schemaId: string) {
+    super(`Unknown schema: "${schemaId}"`);
+    this.data = {schemaId};
+  }
+}
+
+/**
+ * Thrown when provided schema type is unsupported (boolean/async/non-object).
+ */
+export class SchemaUnsupportedSchemaError extends TypeError {
+  readonly code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA' as const;
+  readonly data: Readonly<{schema: any; extType: ExtensionType; extName: string}>;
+
+  constructor(schema: any, extType: ExtensionType, extName: string) {
+    super(
+      (() => {
+        const msg = `Unsupported schema from ${extType} "${extName}":`;
+        if (_.isBoolean(schema)) {
+          return `${msg} schema cannot be a boolean`;
+        }
+        if (_.isPlainObject(schema)) {
+          if ((schema as any).$async) {
+            return `${msg} schema cannot be an async schema`;
+          }
+          throw new TypeError(
+            `schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(
+              schema
+            )}`
+          );
+        }
+        return `${msg} schema must be a plain object without a true "$async" property`;
+      })()
+    );
+    this.data = {schema, extType, extName};
+  }
+}
+
+const appiumSchema = AppiumSchema.create();
+
+export const {
+  registerSchema,
+  getAllArgSpecs,
+  getArgSpec,
+  hasArgSpec,
+  isFinalized,
+  finalize: finalizeSchema,
+  reset: resetSchema,
+  validate,
+  getSchema,
+  flatten: flattenSchema,
+  getDefaults: getDefaultsForSchema,
+  getDefaultsForExtension,
+} = appiumSchema;
+
+export const {isAllowedSchemaFileExtension} = AppiumSchema;

package/lib/utils.ts

@@ -0,0 +1,73 @@
+import _ from 'lodash';
+import {node, fs} from '@appium/support';
+
+export const npmPackage = fs.readPackageJsonFrom(__dirname);
+
+/**
+ * Returns the root directory of the Appium module (memoized).
+ *
+ * @throws {Error} If the appium module root cannot be determined.
+ */
+export const getAppiumModuleRoot = _.memoize(function getAppiumModuleRoot(): string {
+  const selfRoot = node.getModuleRootSync('appium', __filename);
+  if (!selfRoot) {
+    throw new Error('Cannot find the appium module root. This is likely a bug in Appium.');
+  }
+  return selfRoot;
+});
+
+/**
+ * Adler-32 checksum (see https://github.com/SheetJS/js-adler32).
+ */
+export function adler32(str: string, seed: number | null = null): number {
+  let a = 1,
+    b = 0,
+    M = 0,
+    c = 0,
+    d = 0;
+  const L = str.length;
+  if (typeof seed === 'number') {
+    a = seed & 0xffff;
+    b = seed >>> 16;
+  }
+  for (let i = 0; i < L;) {
+    M = Math.min(L - i, 2918);
+    while (M > 0) {
+      c = str.charCodeAt(i++);
+      if (c < 0x80) {
+        a += c;
+      } else if (c < 0x800) {
+        a += 192 | ((c >> 6) & 31);
+        b += a;
+        --M;
+        a += 128 | (c & 63);
+      } else if (c >= 0xd800 && c < 0xe000) {
+        c = (c & 1023) + 64;
+        d = str.charCodeAt(i++) & 1023;
+        a += 240 | ((c >> 8) & 7);
+        b += a;
+        --M;
+        a += 128 | ((c >> 2) & 63);
+        b += a;
+        --M;
+        a += 128 | ((d >> 6) & 15) | ((c & 3) << 4);
+        b += a;
+        --M;
+        a += 128 | (d & 63);
+      } else {
+        a += 224 | ((c >> 12) & 15);
+        b += a;
+        --M;
+        a += 128 | ((c >> 6) & 63);
+        b += a;
+        --M;
+        a += 128 | (c & 63);
+      }
+      b += a;
+      --M;
+    }
+    a = 15 * (a >>> 16) + (a & 65535);
+    b = 15 * (b >>> 16) + (b & 65535);
+  }
+  return ((b % 65521) << 16) | (a % 65521);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium",
-  "version": "3.2.2",
+  "version": "3.3.1",
   "description": "Automation for Apps.",
   "keywords": [
     "automation",
@@ -60,32 +60,31 @@
     "test:unit": "mocha \"./test/unit/**/*.spec.ts\""
   },
   "dependencies": {
-    "@appium/base-driver": "^10.2.2",
-    "@appium/base-plugin": "^3.1.1",
-    "@appium/docutils": "^2.2.2",
-    "@appium/logger": "^2.0.5",
-    "@appium/schema": "^1.1.0",
-    "@appium/support": "^7.0.6",
-    "@appium/types": "^1.2.1",
-    "@sidvind/better-ajv-errors": "4.0.1",
+    "@appium/base-driver": "10.4.0",
+    "@appium/base-plugin": "3.2.1",
+    "@appium/docutils": "2.3.1",
+    "@appium/logger": "2.0.7",
+    "@appium/schema": "1.1.0",
+    "@appium/support": "7.1.1",
+    "@appium/types": "1.3.1",
+    "@sidvind/better-ajv-errors": "5.0.0",
     "ajv": "8.18.0",
     "ajv-formats": "3.0.1",
     "argparse": "2.0.1",
-    "async-lock": "1.4.1",
-    "axios": "1.13.6",
+    "axios": "1.15.0",
     "bluebird": "3.7.2",
     "lilconfig": "3.1.3",
-    "lodash": "4.17.23",
-    "lru-cache": "11.2.6",
+    "lodash": "4.18.1",
+    "lru-cache": "11.3.5",
     "ora": "5.4.1",
     "package-changed": "3.0.0",
     "resolve-from": "5.0.0",
     "semver": "7.7.4",
-    "teen_process": "4.0.10",
-    "type-fest": "5.4.4",
+    "teen_process": "4.1.1",
+    "type-fest": "5.6.0",
     "winston": "3.19.0",
-    "ws": "8.19.0",
-    "yaml": "2.8.2"
+    "ws": "8.20.0",
+    "yaml": "2.8.3"
   },
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
@@ -94,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c745352c6500937a4590d1ef6ef19785143a8870"
+  "gitHead": "17f84265d10944fec06ae7684ae8ad77d1224b50"
 }

package/scripts/autoinstall-extensions.js

@@ -98,6 +98,9 @@ async function init() {
   }
 }
 
+/**
+ * Installs drivers/plugins requested via npm config vars.
+ */
 async function main() {
   if (!(await init())) {
     return;

package/build/lib/config-file.d.ts

@@ -1,100 +0,0 @@
-/**
- * Given an array of errors and the result of loading a config file, generate a
- * helpful string for the user.
- *
- * - If `opts` contains a `json` property, this should be the original JSON
- *   _string_ of the config file.  This is only applicable if the config file
- *   was in JSON format. If present, it will associate line numbers with errors.
- * - If `errors` happens to be empty, this will throw.
- * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.
- * @param {ReadConfigFileResult['config']|any} [config] -
- * Configuration & metadata
- * @param {FormatConfigErrorsOptions} [opts]
- * @throws {TypeError} If `errors` is empty
- * @returns {string}
- */
-export function formatErrors(errors?: import("ajv").ErrorObject[], config?: ReadConfigFileResult["config"] | any, opts?: FormatConfigErrorsOptions): string;
-/**
- * Given an optional path, read a config file. Validates the config file.
- *
- * Call {@link validate} if you already have a config object.
- * @param {string} [filepath] - Path to config file, if we have one
- * @param {ReadConfigFileOptions} [opts] - Options
- * @public
- * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors
- */
-export function readConfigFile(filepath?: string, opts?: ReadConfigFileOptions): Promise<ReadConfigFileResult>;
-/**
- * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case
- * @param {AppiumConfig} config - Configuration object
- * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).
- */
-export function normalizeConfig(config: AppiumConfig): NormalizedAppiumConfig;
-/**
- * Result of calling {@link readConfigFile}.
- */
-export type ReadConfigFileResult = {
-    /**
-     * - Validation errors
-     */
-    errors?: import("ajv").ErrorObject<string, Record<string, any>, any>[] | undefined;
-    /**
-     * - The path to the config file, if found
-     */
-    filepath?: string | undefined;
-    /**
-     * - If `true`, the config file exists but is empty
-     */
-    isEmpty?: boolean | undefined;
-    /**
-     * - The parsed configuration
-     */
-    config?: import("@appium/types").NormalizedAppiumConfig | undefined;
-    /**
-     * - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.
-     */
-    reason?: string | import("@sidvind/better-ajv-errors").IOutputError[] | undefined;
-};
-/**
- * Options for {@link readConfigFile}.
- */
-export type ReadConfigFileOptions = {
-    /**
-     * If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult}. The value of `reason` is then suitable for machine-reading.
-     */
-    pretty?: boolean | undefined;
-};
-/**
- * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.
- */
-export type LilconfigAsyncSearcher = ReturnType<typeof import("lilconfig")["lilconfig"]>;
-/**
- * The contents of an Appium config file. Generated from schema
- */
-export type AppiumConfig = import("@appium/types").AppiumConfig;
-/**
- * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}
- */
-export type NormalizedAppiumConfig = import("@appium/types").NormalizedAppiumConfig;
-/**
- * The string should be a raw JSON string.
- */
-export type RawJson = string;
-/**
- * Options for {@link formatErrors}.
- */
-export type FormatConfigErrorsOptions = {
-    /**
-     * - Raw JSON config (as string)
-     */
-    json?: string | undefined;
-    /**
-     * - Whether to format errors as a CLI-friendly string
-     */
-    pretty?: boolean | undefined;
-    /**
-     * - Specific ID of a prop; otherwise entire schema
-     */
-    schemaId?: string | undefined;
-};
-//# sourceMappingURL=config-file.d.ts.map

package/build/lib/config-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config-file.d.ts","sourceRoot":"","sources":["../../lib/config-file.js"],"names":[],"mappings":"AA0EA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,OAAO,KAAK,EAAE,WAAW,EAAE,WAC3B,oBAAoB,CAAC,QAAQ,CAAC,GAAC,GAAG,SAElC,yBAAyB,GAEvB,MAAM,CAUlB;AAED;;;;;;;;GAQG;AACH,0CALW,MAAM,SACN,qBAAqB,GAEnB,OAAO,CAAC,oBAAoB,CAAC,CAwCzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CAgClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoBY,UAAU,CAAC,0BAAmB,CAAC,WAAW,CAAC,CAAC;;;;2BAK5C,OAAO,eAAe,EAAE,YAAY;;;;qCAKpC,OAAO,eAAe,EAAE,sBAAsB;;;;sBAK9C,MAAM"}