@itwin/ecschema-locaters 4.0.0-dev.28 → 4.0.0-dev.32

package/lib/cjs/SchemaFileLocater.d.ts

@@ -1,83 +1,83 @@
-import { Schema, SchemaContext, SchemaKey, SchemaMatchType } from "@itwin/ecschema-metadata";
-/**
- * A SchemaKey implementation that aids in identifying Schema files via the
- * addition of two properties: fileName and schemaText.  The fileName contains the
- * full path to the file on disk and schemaText is the full string representation
- * of the Schema.
- * @beta
- */
-export declare class FileSchemaKey extends SchemaKey {
-    fileName: string;
-    schemaText?: string;
-    /**
-     * Initializes a new FileSchemaKey object.
-     * @param key The EC SchemaKey identifying the Schema.
-     * @param fileName The full path to the Schema file.
-     * @param schemaText The string representation of the Schema
-     * loaded from disk. Optional.
-     */
-    constructor(key: SchemaKey, fileName: string, schemaJson?: string);
-}
-/**
- * Abstract class to hold common/overlapping functionality between SchemaJsonFileLocater and SchemaXmlFileLocater
- * @beta - Needs further testing and possibly moved to a separate package.
- */
-export declare abstract class SchemaFileLocater {
-    searchPaths: string[];
-    constructor();
-    readUtf8FileToString(filePath: string): Promise<string | undefined>;
-    readUtf8FileToStringSync(filePath: string): string | undefined;
-    fileExists(filePath: string): Promise<boolean | undefined>;
-    fileExistsSync(filePath: string): boolean | undefined;
-    /**
-     * Adds more search paths used by this locator to find the
-     * Schema files.
-     * @param schemaPaths An array of search paths to add
-     */
-    addSchemaSearchPaths(schemaPaths: string[]): void;
-    /**
-     * Add one search path used by this locator to find the
-     * Schema files.
-     * @param schemaPath A search path to add
-     */
-    addSchemaSearchPath(schemaPath: string): void;
-    protected abstract getSchemaKey(data: string): SchemaKey;
-    /**
-     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey. This method
-     * only attempts to find schema files that have no version in the file name.
-     * @param foundFiles The collection of SchemaKeys found in the given directory.
-     * @param schemaPath The directory in which to search for the Schemas.
-     * @param schemaName The short name of the Schema (without version).
-     * @param desiredKey The SchemaKey used to find matching Schema files.
-     * @param matchType The SchemaMatchType to use when comparing the desiredKey and the keys found during the search.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    private addCandidateNoExtSchemaKey;
-    /**
-     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey
-     * @param foundFiles The collection of SchemaKeys found in the given directory
-     * @param schemaPath The directory in which to search for the Schemas
-     * @param fileFilter The file filter, potentially with wildcards, used to locate the Schema files.
-     * @param desiredKey The schemaKey used to find matching Schema files
-     * @param matchType The SchemaMatchType to use when comparing the desired Key and the keys found during the search.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    private addCandidateSchemaKeys;
-    /**
-     * Attempts to find all Schema files in the configurable search paths that match
-     * the desired SchemaKey.
-     * @param desiredKey The SchemaKey to match.
-     * @param matchType The SchemaMatchType.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    protected findEligibleSchemaKeys(desiredKey: SchemaKey, matchType: SchemaMatchType, format: string): FileSchemaKey[];
-    abstract getSchema<T extends Schema>(key: SchemaKey, matchType: SchemaMatchType, context: SchemaContext): Promise<T | undefined>;
-    /**
-     * Compares two Schema versions.  If the left-hand version is greater, 1 is returned. If the
-     * left-hand version is less, -1 us returned.  If the versions are an exact match, 0 is returned.
-     * @param lhs The 'left-hand' FileSchemaKey.
-     * @param rhs The 'right-hand' FileSchemaKey.
-     */
-    compareSchemaKeyByVersion: (lhs: FileSchemaKey, rhs: FileSchemaKey) => number;
-}
+import { Schema, SchemaContext, SchemaKey, SchemaMatchType } from "@itwin/ecschema-metadata";
+/**
+ * A SchemaKey implementation that aids in identifying Schema files via the
+ * addition of two properties: fileName and schemaText.  The fileName contains the
+ * full path to the file on disk and schemaText is the full string representation
+ * of the Schema.
+ * @beta
+ */
+export declare class FileSchemaKey extends SchemaKey {
+    fileName: string;
+    schemaText?: string;
+    /**
+     * Initializes a new FileSchemaKey object.
+     * @param key The EC SchemaKey identifying the Schema.
+     * @param fileName The full path to the Schema file.
+     * @param schemaText The string representation of the Schema
+     * loaded from disk. Optional.
+     */
+    constructor(key: SchemaKey, fileName: string, schemaJson?: string);
+}
+/**
+ * Abstract class to hold common/overlapping functionality between SchemaJsonFileLocater and SchemaXmlFileLocater
+ * @beta - Needs further testing and possibly moved to a separate package.
+ */
+export declare abstract class SchemaFileLocater {
+    searchPaths: string[];
+    constructor();
+    readUtf8FileToString(filePath: string): Promise<string | undefined>;
+    readUtf8FileToStringSync(filePath: string): string | undefined;
+    fileExists(filePath: string): Promise<boolean | undefined>;
+    fileExistsSync(filePath: string): boolean | undefined;
+    /**
+     * Adds more search paths used by this locator to find the
+     * Schema files.
+     * @param schemaPaths An array of search paths to add
+     */
+    addSchemaSearchPaths(schemaPaths: string[]): void;
+    /**
+     * Add one search path used by this locator to find the
+     * Schema files.
+     * @param schemaPath A search path to add
+     */
+    addSchemaSearchPath(schemaPath: string): void;
+    protected abstract getSchemaKey(data: string): SchemaKey;
+    /**
+     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey. This method
+     * only attempts to find schema files that have no version in the file name.
+     * @param foundFiles The collection of SchemaKeys found in the given directory.
+     * @param schemaPath The directory in which to search for the Schemas.
+     * @param schemaName The short name of the Schema (without version).
+     * @param desiredKey The SchemaKey used to find matching Schema files.
+     * @param matchType The SchemaMatchType to use when comparing the desiredKey and the keys found during the search.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    private addCandidateNoExtSchemaKey;
+    /**
+     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey
+     * @param foundFiles The collection of SchemaKeys found in the given directory
+     * @param schemaPath The directory in which to search for the Schemas
+     * @param fileFilter The file filter, potentially with wildcards, used to locate the Schema files.
+     * @param desiredKey The schemaKey used to find matching Schema files
+     * @param matchType The SchemaMatchType to use when comparing the desired Key and the keys found during the search.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    private addCandidateSchemaKeys;
+    /**
+     * Attempts to find all Schema files in the configurable search paths that match
+     * the desired SchemaKey.
+     * @param desiredKey The SchemaKey to match.
+     * @param matchType The SchemaMatchType.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    protected findEligibleSchemaKeys(desiredKey: SchemaKey, matchType: SchemaMatchType, format: string): FileSchemaKey[];
+    abstract getSchema<T extends Schema>(key: SchemaKey, matchType: SchemaMatchType, context: SchemaContext): Promise<T | undefined>;
+    /**
+     * Compares two Schema versions.  If the left-hand version is greater, 1 is returned. If the
+     * left-hand version is less, -1 us returned.  If the versions are an exact match, 0 is returned.
+     * @param lhs The 'left-hand' FileSchemaKey.
+     * @param rhs The 'right-hand' FileSchemaKey.
+     */
+    compareSchemaKeyByVersion: (lhs: FileSchemaKey, rhs: FileSchemaKey) => number;
+}
 //# sourceMappingURL=SchemaFileLocater.d.ts.map

package/lib/cjs/SchemaFileLocater.js

@@ -1,213 +1,213 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaFileLocater = exports.FileSchemaKey = void 0;
-const fs = require("fs");
-const glob = require("glob");
-const path = require("path");
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/** @packageDocumentation
- * @module Locaters
- */
-const formatString = (format, ...args) => {
-    return format.replace(/{(\d+)}/g, (match, theNumber) => {
-        return typeof args[theNumber] !== "undefined"
-            ? args[theNumber]
-            : match;
-    });
-};
-const padStartEx = (str, targetLength, padString) => {
-    targetLength = targetLength >> 0; // truncate if number or convert non-number to 0;
-    padString = String((typeof padString !== "undefined" ? padString : " "));
-    if (str.length > targetLength) {
-        return String(str);
-    }
-    else {
-        targetLength = targetLength - str.length;
-        if (targetLength > padString.length) {
-            padString += padString.repeat(targetLength / padString.length); // append to original to ensure we are longer than needed
-        }
-        return padString.slice(0, targetLength) + str;
-    }
-};
-/**
- * A SchemaKey implementation that aids in identifying Schema files via the
- * addition of two properties: fileName and schemaText.  The fileName contains the
- * full path to the file on disk and schemaText is the full string representation
- * of the Schema.
- * @beta
- */
-class FileSchemaKey extends ecschema_metadata_1.SchemaKey {
-    /**
-     * Initializes a new FileSchemaKey object.
-     * @param key The EC SchemaKey identifying the Schema.
-     * @param fileName The full path to the Schema file.
-     * @param schemaText The string representation of the Schema
-     * loaded from disk. Optional.
-     */
-    constructor(key, fileName, schemaJson) {
-        super(key.name, key.version);
-        this.fileName = fileName;
-        this.schemaText = schemaJson;
-    }
-}
-exports.FileSchemaKey = FileSchemaKey;
-/**
- * Abstract class to hold common/overlapping functionality between SchemaJsonFileLocater and SchemaXmlFileLocater
- * @beta - Needs further testing and possibly moved to a separate package.
- */
-class SchemaFileLocater {
-    constructor() {
-        /**
-         * Compares two Schema versions.  If the left-hand version is greater, 1 is returned. If the
-         * left-hand version is less, -1 us returned.  If the versions are an exact match, 0 is returned.
-         * @param lhs The 'left-hand' FileSchemaKey.
-         * @param rhs The 'right-hand' FileSchemaKey.
-         */
-        this.compareSchemaKeyByVersion = (lhs, rhs) => {
-            return lhs.compareByVersion(rhs);
-        };
-        this.searchPaths = [];
-    }
-    async readUtf8FileToString(filePath) {
-        return new Promise((resolve, reject) => {
-            fs.readFile(filePath, "utf-8", (err, data) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(data);
-            });
-        });
-    }
-    readUtf8FileToStringSync(filePath) {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    async fileExists(filePath) {
-        return new Promise((resolve) => {
-            fs.access(filePath, fs.constants.F_OK, (err) => {
-                resolve(err ? false : true);
-            });
-        });
-    }
-    fileExistsSync(filePath) {
-        return fs.existsSync(filePath);
-    }
-    /**
-     * Adds more search paths used by this locator to find the
-     * Schema files.
-     * @param schemaPaths An array of search paths to add
-     */
-    addSchemaSearchPaths(schemaPaths) {
-        // If the path is not in the schemaPaths array, add it
-        for (const schemaPath of schemaPaths)
-            this.addSchemaSearchPath(schemaPath);
-    }
-    /**
-     * Add one search path used by this locator to find the
-     * Schema files.
-     * @param schemaPath A search path to add
-     */
-    addSchemaSearchPath(schemaPath) {
-        // If the path is not in the schemaPaths array, add it
-        if (!this.searchPaths.find((entry) => entry === schemaPath))
-            this.searchPaths.push(schemaPath);
-    }
-    /**
-     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey. This method
-     * only attempts to find schema files that have no version in the file name.
-     * @param foundFiles The collection of SchemaKeys found in the given directory.
-     * @param schemaPath The directory in which to search for the Schemas.
-     * @param schemaName The short name of the Schema (without version).
-     * @param desiredKey The SchemaKey used to find matching Schema files.
-     * @param matchType The SchemaMatchType to use when comparing the desiredKey and the keys found during the search.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    addCandidateNoExtSchemaKey(foundFiles, schemaPath, schemaName, desiredKey, matchType, format) {
-        const fullPath = path.join(schemaPath, `${schemaName}.ecschema.${format}`);
-        // If the file does not exist, end
-        if (!fs.existsSync(fullPath))
-            return;
-        // Read the file
-        const file = fs.readFileSync(fullPath);
-        if (!file)
-            return;
-        // Get the schema key
-        const key = this.getSchemaKey(file.toString());
-        // If the key matches, put it in foundFiles
-        if (key.matches(desiredKey, matchType))
-            foundFiles.push(new FileSchemaKey(key, fullPath, file.toString()));
-    }
-    /**
-     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey
-     * @param foundFiles The collection of SchemaKeys found in the given directory
-     * @param schemaPath The directory in which to search for the Schemas
-     * @param fileFilter The file filter, potentially with wildcards, used to locate the Schema files.
-     * @param desiredKey The schemaKey used to find matching Schema files
-     * @param matchType The SchemaMatchType to use when comparing the desired Key and the keys found during the search.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    addCandidateSchemaKeys(foundFiles, schemaPath, fileFilter, desiredKey, matchType, format) {
-        const fullPath = path.join(schemaPath, fileFilter);
-        const result = new glob.GlobSync(fullPath, { sync: true });
-        for (const match of result.found) {
-            let fileName = path.basename(match, (`.ecschema.${format}`));
-            // TODO: should this be moved or handled elsewhere?
-            // Handles two version file names - SchemaKey.parseString supports only 3 version names.
-            if (/[^\d]\.\d?\d\.\d?\d$/.test(fileName)) {
-                const parts = fileName.split(".");
-                parts.splice(2, 0, "00");
-                fileName = parts.join(".");
-            }
-            const file = fs.readFileSync(match);
-            if (!file)
-                continue;
-            const schemaKey = ecschema_metadata_1.SchemaKey.parseString(fileName);
-            if (schemaKey.matches(desiredKey, matchType))
-                foundFiles.push(new FileSchemaKey(schemaKey, match, file.toString()));
-        }
-    }
-    /**
-     * Attempts to find all Schema files in the configurable search paths that match
-     * the desired SchemaKey.
-     * @param desiredKey The SchemaKey to match.
-     * @param matchType The SchemaMatchType.
-     * @param format The type of file that the schema key refers to. json or xml
-     */
-    findEligibleSchemaKeys(desiredKey, matchType, format) {
-        const foundFiles = new Array();
-        let twoVersionSuffix;
-        let threeVersionSuffix;
-        const readVersion = desiredKey.readVersion.toString();
-        const writeVersion = desiredKey.writeVersion.toString();
-        const minorVersion = desiredKey.minorVersion.toString();
-        if (matchType === ecschema_metadata_1.SchemaMatchType.Latest) {
-            twoVersionSuffix = (`.*.*.ecschema.${format}`);
-            threeVersionSuffix = (`.*.*.*.ecschema.${format}`);
-        }
-        else if (matchType === ecschema_metadata_1.SchemaMatchType.LatestWriteCompatible) {
-            twoVersionSuffix = formatString(`.{0}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
-            threeVersionSuffix = formatString(`.{0}.{1}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"));
-        }
-        else if (matchType === ecschema_metadata_1.SchemaMatchType.LatestReadCompatible) {
-            twoVersionSuffix = formatString(`.{0}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
-            threeVersionSuffix = formatString(`.{0}.*.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
-        }
-        else {
-            twoVersionSuffix = formatString(`.{0}.{1}.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"));
-            threeVersionSuffix = formatString(`.{0}.{1}.{2}.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"), padStartEx(minorVersion, 2, "0"));
-        }
-        const twoVersionExpression = desiredKey.name + twoVersionSuffix;
-        const threeVersionExpression = desiredKey.name + threeVersionSuffix;
-        for (const searchPath of this.searchPaths) {
-            this.addCandidateNoExtSchemaKey(foundFiles, searchPath, desiredKey.name, desiredKey, matchType, format);
-            this.addCandidateSchemaKeys(foundFiles, searchPath, twoVersionExpression, desiredKey, matchType, format);
-            this.addCandidateSchemaKeys(foundFiles, searchPath, threeVersionExpression, desiredKey, matchType, format);
-        }
-        return foundFiles;
-    }
-}
-exports.SchemaFileLocater = SchemaFileLocater;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaFileLocater = exports.FileSchemaKey = void 0;
+const fs = require("fs");
+const glob = require("glob");
+const path = require("path");
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/** @packageDocumentation
+ * @module Locaters
+ */
+const formatString = (format, ...args) => {
+    return format.replace(/{(\d+)}/g, (match, theNumber) => {
+        return typeof args[theNumber] !== "undefined"
+            ? args[theNumber]
+            : match;
+    });
+};
+const padStartEx = (str, targetLength, padString) => {
+    targetLength = targetLength >> 0; // truncate if number or convert non-number to 0;
+    padString = String((typeof padString !== "undefined" ? padString : " "));
+    if (str.length > targetLength) {
+        return String(str);
+    }
+    else {
+        targetLength = targetLength - str.length;
+        if (targetLength > padString.length) {
+            padString += padString.repeat(targetLength / padString.length); // append to original to ensure we are longer than needed
+        }
+        return padString.slice(0, targetLength) + str;
+    }
+};
+/**
+ * A SchemaKey implementation that aids in identifying Schema files via the
+ * addition of two properties: fileName and schemaText.  The fileName contains the
+ * full path to the file on disk and schemaText is the full string representation
+ * of the Schema.
+ * @beta
+ */
+class FileSchemaKey extends ecschema_metadata_1.SchemaKey {
+    /**
+     * Initializes a new FileSchemaKey object.
+     * @param key The EC SchemaKey identifying the Schema.
+     * @param fileName The full path to the Schema file.
+     * @param schemaText The string representation of the Schema
+     * loaded from disk. Optional.
+     */
+    constructor(key, fileName, schemaJson) {
+        super(key.name, key.version);
+        this.fileName = fileName;
+        this.schemaText = schemaJson;
+    }
+}
+exports.FileSchemaKey = FileSchemaKey;
+/**
+ * Abstract class to hold common/overlapping functionality between SchemaJsonFileLocater and SchemaXmlFileLocater
+ * @beta - Needs further testing and possibly moved to a separate package.
+ */
+class SchemaFileLocater {
+    constructor() {
+        /**
+         * Compares two Schema versions.  If the left-hand version is greater, 1 is returned. If the
+         * left-hand version is less, -1 us returned.  If the versions are an exact match, 0 is returned.
+         * @param lhs The 'left-hand' FileSchemaKey.
+         * @param rhs The 'right-hand' FileSchemaKey.
+         */
+        this.compareSchemaKeyByVersion = (lhs, rhs) => {
+            return lhs.compareByVersion(rhs);
+        };
+        this.searchPaths = [];
+    }
+    async readUtf8FileToString(filePath) {
+        return new Promise((resolve, reject) => {
+            fs.readFile(filePath, "utf-8", (err, data) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(data);
+            });
+        });
+    }
+    readUtf8FileToStringSync(filePath) {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    async fileExists(filePath) {
+        return new Promise((resolve) => {
+            fs.access(filePath, fs.constants.F_OK, (err) => {
+                resolve(err ? false : true);
+            });
+        });
+    }
+    fileExistsSync(filePath) {
+        return fs.existsSync(filePath);
+    }
+    /**
+     * Adds more search paths used by this locator to find the
+     * Schema files.
+     * @param schemaPaths An array of search paths to add
+     */
+    addSchemaSearchPaths(schemaPaths) {
+        // If the path is not in the schemaPaths array, add it
+        for (const schemaPath of schemaPaths)
+            this.addSchemaSearchPath(schemaPath);
+    }
+    /**
+     * Add one search path used by this locator to find the
+     * Schema files.
+     * @param schemaPath A search path to add
+     */
+    addSchemaSearchPath(schemaPath) {
+        // If the path is not in the schemaPaths array, add it
+        if (!this.searchPaths.find((entry) => entry === schemaPath))
+            this.searchPaths.push(schemaPath);
+    }
+    /**
+     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey. This method
+     * only attempts to find schema files that have no version in the file name.
+     * @param foundFiles The collection of SchemaKeys found in the given directory.
+     * @param schemaPath The directory in which to search for the Schemas.
+     * @param schemaName The short name of the Schema (without version).
+     * @param desiredKey The SchemaKey used to find matching Schema files.
+     * @param matchType The SchemaMatchType to use when comparing the desiredKey and the keys found during the search.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    addCandidateNoExtSchemaKey(foundFiles, schemaPath, schemaName, desiredKey, matchType, format) {
+        const fullPath = path.join(schemaPath, `${schemaName}.ecschema.${format}`);
+        // If the file does not exist, end
+        if (!fs.existsSync(fullPath))
+            return;
+        // Read the file
+        const file = fs.readFileSync(fullPath);
+        if (!file)
+            return;
+        // Get the schema key
+        const key = this.getSchemaKey(file.toString());
+        // If the key matches, put it in foundFiles
+        if (key.matches(desiredKey, matchType))
+            foundFiles.push(new FileSchemaKey(key, fullPath, file.toString()));
+    }
+    /**
+     * Adds SchemaKeys to the provided foundFiles collection that match the desired SchemaKey
+     * @param foundFiles The collection of SchemaKeys found in the given directory
+     * @param schemaPath The directory in which to search for the Schemas
+     * @param fileFilter The file filter, potentially with wildcards, used to locate the Schema files.
+     * @param desiredKey The schemaKey used to find matching Schema files
+     * @param matchType The SchemaMatchType to use when comparing the desired Key and the keys found during the search.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    addCandidateSchemaKeys(foundFiles, schemaPath, fileFilter, desiredKey, matchType, format) {
+        const fullPath = path.join(schemaPath, fileFilter);
+        const result = new glob.GlobSync(fullPath, { sync: true });
+        for (const match of result.found) {
+            let fileName = path.basename(match, (`.ecschema.${format}`));
+            // TODO: should this be moved or handled elsewhere?
+            // Handles two version file names - SchemaKey.parseString supports only 3 version names.
+            if (/[^\d]\.\d?\d\.\d?\d$/.test(fileName)) {
+                const parts = fileName.split(".");
+                parts.splice(2, 0, "00");
+                fileName = parts.join(".");
+            }
+            const file = fs.readFileSync(match);
+            if (!file)
+                continue;
+            const schemaKey = ecschema_metadata_1.SchemaKey.parseString(fileName);
+            if (schemaKey.matches(desiredKey, matchType))
+                foundFiles.push(new FileSchemaKey(schemaKey, match, file.toString()));
+        }
+    }
+    /**
+     * Attempts to find all Schema files in the configurable search paths that match
+     * the desired SchemaKey.
+     * @param desiredKey The SchemaKey to match.
+     * @param matchType The SchemaMatchType.
+     * @param format The type of file that the schema key refers to. json or xml
+     */
+    findEligibleSchemaKeys(desiredKey, matchType, format) {
+        const foundFiles = new Array();
+        let twoVersionSuffix;
+        let threeVersionSuffix;
+        const readVersion = desiredKey.readVersion.toString();
+        const writeVersion = desiredKey.writeVersion.toString();
+        const minorVersion = desiredKey.minorVersion.toString();
+        if (matchType === ecschema_metadata_1.SchemaMatchType.Latest) {
+            twoVersionSuffix = (`.*.*.ecschema.${format}`);
+            threeVersionSuffix = (`.*.*.*.ecschema.${format}`);
+        }
+        else if (matchType === ecschema_metadata_1.SchemaMatchType.LatestWriteCompatible) {
+            twoVersionSuffix = formatString(`.{0}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
+            threeVersionSuffix = formatString(`.{0}.{1}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"));
+        }
+        else if (matchType === ecschema_metadata_1.SchemaMatchType.LatestReadCompatible) {
+            twoVersionSuffix = formatString(`.{0}.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
+            threeVersionSuffix = formatString(`.{0}.*.*.ecschema.${format}`, padStartEx(readVersion, 2, "0"));
+        }
+        else {
+            twoVersionSuffix = formatString(`.{0}.{1}.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"));
+            threeVersionSuffix = formatString(`.{0}.{1}.{2}.ecschema.${format}`, padStartEx(readVersion, 2, "0"), padStartEx(writeVersion, 2, "0"), padStartEx(minorVersion, 2, "0"));
+        }
+        const twoVersionExpression = desiredKey.name + twoVersionSuffix;
+        const threeVersionExpression = desiredKey.name + threeVersionSuffix;
+        for (const searchPath of this.searchPaths) {
+            this.addCandidateNoExtSchemaKey(foundFiles, searchPath, desiredKey.name, desiredKey, matchType, format);
+            this.addCandidateSchemaKeys(foundFiles, searchPath, twoVersionExpression, desiredKey, matchType, format);
+            this.addCandidateSchemaKeys(foundFiles, searchPath, threeVersionExpression, desiredKey, matchType, format);
+        }
+        return foundFiles;
+    }
+}
+exports.SchemaFileLocater = SchemaFileLocater;
 //# sourceMappingURL=SchemaFileLocater.js.map