@depup/graphql-codegen__cli 6.2.1-depup.0

package/cjs/load.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDocumentsLoadOptions = exports.defaultSchemaLoadOptions = void 0;
+exports.loadSchema = loadSchema;
+exports.loadDocuments = loadDocuments;
+const path_1 = require("path");
+const apollo_engine_loader_1 = require("@graphql-tools/apollo-engine-loader");
+const code_file_loader_1 = require("@graphql-tools/code-file-loader");
+const git_loader_1 = require("@graphql-tools/git-loader");
+const github_loader_1 = require("@graphql-tools/github-loader");
+const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
+const json_file_loader_1 = require("@graphql-tools/json-file-loader");
+const load_1 = require("@graphql-tools/load");
+const url_loader_1 = require("@graphql-tools/url-loader");
+const graphql_1 = require("graphql");
+exports.defaultSchemaLoadOptions = {
+    assumeValidSDL: true,
+    sort: true,
+    convertExtensions: true,
+    includeSources: true,
+};
+exports.defaultDocumentsLoadOptions = {
+    sort: true,
+    skipGraphQLImport: true,
+};
+async function loadSchema(schemaPointers, config) {
+    try {
+        const loaders = [
+            new code_file_loader_1.CodeFileLoader(),
+            new git_loader_1.GitLoader(),
+            new github_loader_1.GithubLoader(),
+            new graphql_file_loader_1.GraphQLFileLoader(),
+            new json_file_loader_1.JsonFileLoader(),
+            new url_loader_1.UrlLoader(),
+            new apollo_engine_loader_1.ApolloEngineLoader(),
+        ];
+        const schema = await (0, load_1.loadSchema)(schemaPointers, {
+            ...exports.defaultSchemaLoadOptions,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return schema;
+    }
+    catch (e) {
+        throw new Error([
+            `Failed to load schema from ${Object.keys(schemaPointers).join(',')}:`,
+            printError(e),
+            '\nGraphQL Code Generator supports:',
+            '\n- ES Modules and CommonJS exports (export as default or named export "schema")',
+            '- Introspection JSON File',
+            '- URL of GraphQL endpoint',
+            '- Multiple files with type definitions (glob expression)',
+            '- String in config file',
+            '\nTry to use one of above options and run codegen again.\n',
+        ].join('\n'));
+    }
+}
+async function loadDocuments(documentPointers, config) {
+    const loaders = [
+        new code_file_loader_1.CodeFileLoader({
+            pluckConfig: {
+                skipIndent: true,
+            },
+        }),
+        new git_loader_1.GitLoader(),
+        new github_loader_1.GithubLoader(),
+        new graphql_file_loader_1.GraphQLFileLoader(),
+    ];
+    const ignore = [];
+    for (const generatePath of Object.keys(config.generates)) {
+        if ((0, path_1.extname)(generatePath) === '') {
+            // we omit paths that don't resolve to a specific file
+            continue;
+        }
+        ignore.push((0, path_1.join)(process.cwd(), generatePath));
+    }
+    try {
+        const loadedFromToolkit = await (0, load_1.loadDocuments)(documentPointers, {
+            ...exports.defaultDocumentsLoadOptions,
+            ignore,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return loadedFromToolkit;
+    }
+    catch (error) {
+        // NoTypeDefinitionsFound from `@graphql-tools/load` already has a message with pointer, so we can just rethrow the error
+        if (error instanceof load_1.NoTypeDefinitionsFound) {
+            throw error;
+        }
+        // For other errors, we need to add an error message with documentPointers, so it's better for DevX
+        throw new Error([`Failed to load documents from ${Object.keys(documentPointers).join(',')}:`, printError(error)].join('\n'));
+    }
+}
+const printError = (error) => {
+    if (error instanceof graphql_1.GraphQLError) {
+        return String(error);
+    }
+    return [String(error.message || error), String(error.stack)].join('\n');
+};

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugins.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginByName = getPluginByName;
+const path_1 = require("path");
+async function getPluginByName(name, pluginLoader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-template`,
+        `@graphql-codegen/${name}-plugin`,
+        `graphql-codegen-${name}`,
+        `graphql-codegen-${name}-template`,
+        `graphql-codegen-${name}-plugin`,
+        `codegen-${name}`,
+        `codegen-${name}-template`,
+        name,
+    ];
+    const possibleModules = possibleNames.concat((0, path_1.resolve)(process.cwd(), name));
+    for (const moduleName of possibleModules) {
+        try {
+            return await pluginLoader(moduleName);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new Error(`
+              Unable to load template plugin matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimEnd())
+        .join('');
+    throw new Error(`
+        Unable to find template plugin matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/cjs/presets.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPresetByName = getPresetByName;
+const path_1 = require("path");
+async function getPresetByName(name, loader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-preset`,
+        name,
+        (0, path_1.resolve)(process.cwd(), name),
+    ];
+    for (const moduleName of possibleNames) {
+        try {
+            const loaded = await loader(moduleName);
+            if (loaded?.preset) {
+                return loaded.preset;
+            }
+            if (loaded?.default) {
+                return loaded.default;
+            }
+            return loaded;
+        }
+        catch (err) {
+            if (
+            /** CJS Error code */
+            err.code !== 'MODULE_NOT_FOUND' &&
+                /** ESM Error code */
+                err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new Error(`Unable to load preset matching ${name}
+
+              Unable to load preset matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimEnd())
+        .join('');
+    throw new Error(`Unable to find preset matching ${name}
+
+        Unable to find preset matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/cjs/utils/abort-controller-polyfill.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortController = void 0;
+const events_1 = require("events");
+const debugging_js_1 = require("./debugging.js");
+/**
+ * Node v14 does not have AbortSignal or AbortController, so to safely use it in
+ * another module, you can import it from here.
+ *
+ * Node v14.7+ does have it, but only with flag --experimental-abortcontroller
+ *
+ * We don't actually use AbortController anywhere except in tests, but it
+ * still gets called in watcher.ts, so by polyfilling it we can avoid breaking
+ * existing installations using Node v14 without flag --experimental-abortcontroller,
+ * and we also ensure that tests continue to pass under Node v14 without any new flags.
+ *
+ * This polyfill was adapted (TypeScript-ified) from here:
+ * https://github.com/southpolesteve/node-abort-controller/blob/master/index.js
+ */
+class AbortSignalPolyfill {
+    eventEmitter;
+    onabort;
+    aborted;
+    reason;
+    constructor() {
+        this.eventEmitter = new events_1.EventEmitter();
+        this.onabort = null;
+        this.aborted = false;
+        this.reason = undefined;
+    }
+    toString() {
+        return '[object AbortSignal]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortSignal';
+    }
+    removeEventListener(name, handler) {
+        this.eventEmitter.removeListener(name, handler);
+    }
+    addEventListener(name, handler) {
+        this.eventEmitter.on(name, handler);
+    }
+    // @ts-expect-error No Event type in Node 14
+    dispatchEvent(type) {
+        const event = { type, target: this };
+        const handlerName = `on${event.type}`;
+        if (typeof this[handlerName] === 'function')
+            this[handlerName](event);
+        return this.eventEmitter.emit(event.type, event);
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
+        }
+    }
+    static abort(reason) {
+        const controller = new AbortController();
+        controller.abort(reason);
+        return controller.signal;
+    }
+    static timeout(time) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(new Error('TimeoutError')), time);
+        return controller.signal;
+    }
+}
+const AbortSignal = global.AbortSignal ?? AbortSignalPolyfill;
+class AbortControllerPolyfill {
+    signal;
+    constructor() {
+        (0, debugging_js_1.debugLog)('Using polyfilled AbortController');
+        // @ts-expect-error No Event type in Node 14
+        this.signal = new AbortSignal();
+    }
+    abort(reason) {
+        if (this.signal.aborted)
+            return;
+        // @ts-expect-error Not a read only property when polyfilling
+        this.signal.aborted = true;
+        if (reason) {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = reason;
+        }
+        else {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = new Error('AbortError');
+        }
+        // @ts-expect-error No Event type in Node 14
+        this.signal.dispatchEvent('abort');
+    }
+    toString() {
+        return '[object AbortController]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortController';
+    }
+}
+const AbortController = global.AbortController ?? AbortControllerPolyfill;
+exports.AbortController = AbortController;

package/cjs/utils/cli-error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isListrError = isListrError;
+exports.cliError = cliError;
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err;
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError) {
+        process.exit(1);
+    }
+}

package/cjs/utils/debugging.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = debugLog;
+exports.printLogs = printLogs;
+exports.resetLogs = resetLogs;
+const logger_js_1 = require("./logger.js");
+let queue = [];
+function debugLog(message, ...meta) {
+    queue.push({
+        message,
+        meta,
+    });
+}
+function printLogs() {
+    for (const log of queue) {
+        (0, logger_js_1.getLogger)().info(log.message, ...log.meta);
+    }
+    resetLogs();
+}
+function resetLogs() {
+    queue = [];
+}

package/cjs/utils/file-system.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.access = access;
+exports.writeFile = writeFile;
+exports.readFile = readFile;
+exports.unlinkFile = unlinkFile;
+exports.mkdirp = mkdirp;
+const fs_1 = require("fs");
+const { access: fsAccess, writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = fs_1.promises;
+function access(...args) {
+    return fsAccess(...args);
+}
+function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
+}
+function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
+}
+function unlinkFile(filePath, cb) {
+    (0, fs_1.unlink)(filePath, cb);
+}
+function mkdirp(filePath) {
+    return mkdir(filePath, { recursive: true });
+}

package/cjs/utils/get-latest-version.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestVersion = getLatestVersion;
+const fetch_1 = require("@whatwg-node/fetch");
+/**
+ * Fetches the version directly from the registry instead of depending on
+ * an ESM only module as latest-version does.
+ * @param packageName
+ */
+async function getLatestVersion(packageName) {
+    return (0, fetch_1.fetch)(`https://unpkg.com/${packageName}/package.json`)
+        .then(res => res.json())
+        .then(pkg => pkg.version);
+}

package/cjs/utils/helpers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isURL = isURL;
+function isURL(str) {
+    try {
+        const url = new URL(str);
+        return !!url;
+    }
+    catch {
+        return false;
+    }
+}

package/cjs/utils/logger.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;
+exports.setSilentLogger = setSilentLogger;
+exports.useWinstonLogger = useWinstonLogger;
+const ts_log_1 = require("ts-log");
+let logger;
+function getLogger() {
+    return logger || ts_log_1.dummyLogger;
+}
+useWinstonLogger();
+function setLogger(newLogger) {
+    logger = newLogger;
+}
+function setSilentLogger() {
+    logger = ts_log_1.dummyLogger;
+}
+function useWinstonLogger() {
+    if (logger?.levels) {
+        return;
+    }
+    logger = console;
+}

package/cjs/utils/patterns.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortPatterns = exports.makeLocalPatternSet = exports.makeGlobalPatternSet = exports.makeShouldRebuild = exports.allAffirmativePatternsFromPatternSets = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const utils_1 = require("@graphql-tools/utils");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
+const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Flatten a list of pattern sets to be a list of only the affirmative patterns
+ * are contained in all of them.
+ *
+ * This can be used, for example, to find the "longest common prefix directory"
+ * by examining `mm.scan(pattern).base` for each `pattern`.
+ */
+const allAffirmativePatternsFromPatternSets = (patternSets) => {
+    return patternSets.flatMap(patternSet => [
+        ...patternSet.watch.affirmative,
+        ...patternSet.documents.affirmative,
+        ...patternSet.schemas.affirmative,
+    ]);
+};
+exports.allAffirmativePatternsFromPatternSets = allAffirmativePatternsFromPatternSets;
+/**
+ * Create a rebuild trigger that follows the algorithm described here:
+ * https://github.com/dotansimha/graphql-code-generator/issues/9270#issuecomment-1496765045
+ *
+ * There is a flow chart diagram in that comment.
+ *
+ * Basically:
+ *
+ *  * "Global" patterns are defined at top level of config file, and "local"
+ *    patterns are defined for each output target
+ *  * Each pattern can have "watch", "documents", and "schemas"
+ *  * Watch patterns (global and local) always take precedence over documents and
+ *    schemas patterns, i.e. a watch negation always negates, and a watch match is
+ *    a match even if it would be negated by some pattern in documents or schemas
+ *  * The trigger returns true if any output target's local patterns result in
+ *    a match, after considering the precedence of any global and local negations
+ */
+const makeShouldRebuild = ({ globalPatternSet, localPatternSets, }) => {
+    const localMatchers = localPatternSets.map(localPatternSet => {
+        return (path) => {
+            // Is path negated by any negating watch pattern?
+            if (matchesAnyNegatedPattern(path, [...globalPatternSet.watch.negated, ...localPatternSet.watch.negated])) {
+                // Short circut: negations in watch patterns take priority
+                return false;
+            }
+            // Does path match any affirmative watch pattern?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.watch.affirmative,
+                ...localPatternSet.watch.affirmative,
+            ])) {
+                // Immediately return true: Watch pattern takes priority, even if documents or schema would negate it
+                return true;
+            }
+            // Does path match documents patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.documents.affirmative,
+                ...localPatternSet.documents.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.documents.negated, ...localPatternSet.documents.negated])) {
+                return true;
+            }
+            // Does path match schemas patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.schemas.affirmative,
+                ...localPatternSet.schemas.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.schemas.negated, ...localPatternSet.schemas.negated])) {
+                return true;
+            }
+            // Otherwise, there is no match
+            return false;
+        };
+    });
+    /**
+     * Return `true` if `path` should trigger a rebuild
+     */
+    return ({ path: absolutePath }) => {
+        if (!(0, path_1.isAbsolute)(absolutePath)) {
+            throw new Error('shouldRebuild trigger should be called with absolute path');
+        }
+        const path = (0, path_1.relative)(process.cwd(), absolutePath);
+        const shouldRebuild = localMatchers.some(matcher => matcher(path));
+        return shouldRebuild;
+    };
+};
+exports.makeShouldRebuild = makeShouldRebuild;
+/**
+ * Create the pattern set for the "global" (top level) config.
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over local configs, and any schemas and documents patterns will be
+ * mixed into the pattern set of each local config.
+ */
+const makeGlobalPatternSet = (initialContext) => {
+    const config = initialContext.getConfig();
+    return {
+        watch: (0, exports.sortPatterns)([
+            ...(typeof config.watch === 'boolean' ? [] : (0, plugin_helpers_1.normalizeInstanceOrArray)(config.watch ?? [])),
+            (0, path_1.relative)(process.cwd(), initialContext.filepath),
+        ]),
+        schemas: (0, exports.sortPatterns)(makePatternsFromSchemas((0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema))),
+        documents: (0, exports.sortPatterns)(makePatternsFromDocuments((0, plugin_helpers_1.normalizeInstanceOrArray)(config.documents))),
+    };
+};
+exports.makeGlobalPatternSet = makeGlobalPatternSet;
+/**
+ * Create the pattern set for a "local" (output target) config
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over documents or schemas patterns, and the documents and schemas
+ * patterns will be mixed into the pattern set of their respective gobal pattern
+ * set equivalents.
+ */
+const makeLocalPatternSet = (conf) => {
+    return {
+        watch: (0, exports.sortPatterns)((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.watchPattern)),
+        documents: (0, exports.sortPatterns)(makePatternsFromDocuments((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.documents))),
+        schemas: (0, exports.sortPatterns)(makePatternsFromSchemas((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.schema))),
+    };
+};
+exports.makeLocalPatternSet = makeLocalPatternSet;
+/**
+ * Parse a list of micromatch patterns from a list of documents, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromDocuments = (documents) => {
+    const patterns = [];
+    if (documents) {
+        for (const doc of documents) {
+            if (typeof doc === 'string') {
+                patterns.push(doc);
+            }
+            else {
+                patterns.push(...Object.keys(doc));
+            }
+        }
+    }
+    return patterns;
+};
+/**
+ * Parse a list of micromatch patterns from a list of schemas, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromSchemas = (schemas) => {
+    const patterns = [];
+    for (const s of schemas) {
+        const schema = s;
+        if (!(0, helpers_js_1.isURL)(schema) && ((0, is_glob_1.default)(schema) || (0, utils_1.isValidPath)(schema))) {
+            patterns.push(schema);
+        }
+    }
+    return patterns;
+};
+/**
+ * Given a list of micromatch patterns, sort them into `patterns` (all of them),
+ * `affirmative` (only the affirmative patterns), and `negated` (only the negated patterns)
+ *
+ * @param patterns List of micromatch patterns
+ */
+const sortPatterns = (patterns) => ({
+    patterns,
+    affirmative: onlyAffirmativePatterns(patterns),
+    negated: onlyNegatedPatterns(patterns),
+});
+exports.sortPatterns = sortPatterns;
+/**
+ * Filter the provided list of patterns to include only "affirmative" (non-negated) patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyAffirmativePatterns = (patterns) => {
+    return patterns.filter(pattern => !micromatch_1.default.scan(pattern).negated);
+};
+/**
+ * Filter the provided list of patterns to include only negated patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyNegatedPatterns = (patterns) => {
+    return patterns.filter(pattern => micromatch_1.default.scan(pattern).negated);
+};
+/**
+ * Given a list of negated patterns, invert them by removing their negation prefix
+ *
+ * If there is a non-negated pattern in the list, throw an error, because this
+ * function should only be called after filtering the list to be only negated patterns
+ *
+ * @param patterns List of negated micromatch patterns
+ */
+const invertNegatedPatterns = (patterns) => {
+    return patterns.map(pattern => {
+        const scanned = micromatch_1.default.scan(pattern);
+        if (!scanned.negated) {
+            throw new Error(`onlyNegatedPatterns got a non-negated pattern: ${pattern}`);
+        }
+        // Remove the leading prefix (NOTE: this is not always "!")
+        // e.g. mm.scan("!./foo/bar/never-watch.graphql").prefix === '!./'
+        return pattern.slice(scanned.prefix.length);
+    });
+};
+/**
+ * Return true if relativeCandidatePath matches any of the affirmativePatterns
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the supplied affirmativePatterns
+ * @param affirmativePatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyAffirmativePattern = (relativeCandidatePath, affirmativePatterns) => {
+    if ((0, path_1.isAbsolute)(relativeCandidatePath)) {
+        throw new Error('matchesAny should only be called with relative candidate path');
+    }
+    // Developer error: This function is not intended to work with pattern sets including negations
+    if (affirmativePatterns.some(pattern => micromatch_1.default.scan(pattern).negated)) {
+        throw new Error('matchesAnyAffirmativePattern should only include affirmative patterns');
+    }
+    // micromatch.isMatch does not omit matches that are negated by negation patterns,
+    // which is why we require this function only examine affirmative patterns
+    return micromatch_1.default.isMatch(relativeCandidatePath, affirmativePatterns);
+};
+/**
+ * Return true if relativeCandidatePath matches any of the negatedPatterns
+ *
+ * This function will invert the negated patterns and then call matchesAnyAffirmativePattern
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the suppliednegatedPatterns
+ * @param negatedPatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyNegatedPattern = (relativeCandidatePath, negatedPatterns) => {
+    // NOTE: No safety check that negatedPatterns contains only negated, because that will happen in invertedNegatedPatterns
+    return matchesAnyAffirmativePattern(relativeCandidatePath, invertNegatedPatterns(negatedPatterns));
+};