@graphql-tools/load 7.6.0 → 7.7.0-alpha-6c480b2d.0

package/cjs/documents.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDocumentsSync = exports.loadDocuments = exports.NON_OPERATION_KINDS = exports.OPERATION_KINDS = void 0;
+const graphql_1 = require("graphql");
+const load_typedefs_js_1 = require("./load-typedefs.js");
+/**
+ * Kinds of AST nodes that are included in executable documents
+ */
+exports.OPERATION_KINDS = [graphql_1.Kind.OPERATION_DEFINITION, graphql_1.Kind.FRAGMENT_DEFINITION];
+/**
+ * Kinds of AST nodes that are included in type system definition documents
+ */
+exports.NON_OPERATION_KINDS = Object.keys(graphql_1.Kind)
+    .reduce((prev, v) => [...prev, graphql_1.Kind[v]], [])
+    .filter(v => !exports.OPERATION_KINDS.includes(v));
+/**
+ * Asynchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
+function loadDocuments(pointerOrPointers, options) {
+    return (0, load_typedefs_js_1.loadTypedefs)(pointerOrPointers, { noRequire: true, filterKinds: exports.NON_OPERATION_KINDS, ...options });
+}
+exports.loadDocuments = loadDocuments;
+/**
+ * Synchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
+function loadDocumentsSync(pointerOrPointers, options) {
+    return (0, load_typedefs_js_1.loadTypedefsSync)(pointerOrPointers, { noRequire: true, filterKinds: exports.NON_OPERATION_KINDS, ...options });
+}
+exports.loadDocumentsSync = loadDocumentsSync;

package/cjs/filter-document-kind.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterKind = void 0;
+const graphql_1 = require("graphql");
+const process_1 = require("process");
+/**
+ * @internal
+ */
+const filterKind = (content, filterKinds) => {
+    if (content && content.definitions && content.definitions.length && filterKinds && filterKinds.length > 0) {
+        const invalidDefinitions = [];
+        const validDefinitions = [];
+        for (const definitionNode of content.definitions) {
+            if (filterKinds.includes(definitionNode.kind)) {
+                invalidDefinitions.push(definitionNode);
+            }
+            else {
+                validDefinitions.push(definitionNode);
+            }
+        }
+        if (invalidDefinitions.length > 0) {
+            if (process_1.env['DEBUG']) {
+                for (const d of invalidDefinitions) {
+                    console.log(`Filtered document of kind ${d.kind} due to filter policy (${filterKinds.join(', ')})`);
+                }
+            }
+        }
+        return {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: validDefinitions,
+        };
+    }
+    return content;
+};
+exports.filterKind = filterKind;

package/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./load-typedefs.js"), exports);
+tslib_1.__exportStar(require("./schema.js"), exports);
+tslib_1.__exportStar(require("./documents.js"), exports);
+tslib_1.__exportStar(require("./filter-document-kind.js"), exports);

package/cjs/load-typedefs/collect-sources.js

@@ -0,0 +1,195 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSourcesSync = exports.collectSources = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const graphql_1 = require("graphql");
+const load_file_js_1 = require("./load-file.js");
+const helpers_js_1 = require("../utils/helpers.js");
+const custom_loader_js_1 = require("../utils/custom-loader.js");
+const queue_js_1 = require("../utils/queue.js");
+const module_1 = require("module");
+const process_1 = require("process");
+const CONCURRENCY_LIMIT = 50;
+async function collectSources({ pointerOptionMap, options, }) {
+    const sources = [];
+    const queue = (0, queue_js_1.useQueue)({ concurrency: CONCURRENCY_LIMIT });
+    const { addSource, collect } = createHelpers({
+        sources,
+        stack: [collectDocumentString, collectCustomLoader, collectFallback],
+    });
+    for (const pointer in pointerOptionMap) {
+        const pointerOptions = pointerOptionMap[pointer];
+        collect({
+            pointer,
+            pointerOptions,
+            pointerOptionMap,
+            options,
+            addSource,
+            queue: queue.add,
+        });
+    }
+    await queue.runAll();
+    return sources;
+}
+exports.collectSources = collectSources;
+function collectSourcesSync({ pointerOptionMap, options, }) {
+    const sources = [];
+    const queue = (0, queue_js_1.useSyncQueue)();
+    const { addSource, collect } = createHelpers({
+        sources,
+        stack: [collectDocumentString, collectCustomLoaderSync, collectFallbackSync],
+    });
+    for (const pointer in pointerOptionMap) {
+        const pointerOptions = pointerOptionMap[pointer];
+        collect({
+            pointer,
+            pointerOptions,
+            pointerOptionMap,
+            options,
+            addSource,
+            queue: queue.add,
+        });
+    }
+    queue.runAll();
+    return sources;
+}
+exports.collectSourcesSync = collectSourcesSync;
+function createHelpers({ sources, stack }) {
+    const addSource = ({ source }) => {
+        sources.push(source);
+    };
+    const collect = (0, helpers_js_1.useStack)(...stack);
+    return {
+        addSource,
+        collect,
+    };
+}
+function addResultOfCustomLoader({ pointer, result, addSource, }) {
+    if ((0, graphql_1.isSchema)(result)) {
+        addSource({
+            source: {
+                location: pointer,
+                schema: result,
+                document: (0, utils_1.getDocumentNodeFromSchema)(result),
+            },
+            pointer,
+            noCache: true,
+        });
+    }
+    else if (result.kind && result.kind === graphql_1.Kind.DOCUMENT) {
+        addSource({
+            source: {
+                document: result,
+                location: pointer,
+            },
+            pointer,
+        });
+    }
+    else if (result.document) {
+        addSource({
+            source: {
+                location: pointer,
+                ...result,
+            },
+            pointer,
+        });
+    }
+}
+function collectDocumentString({ pointer, pointerOptions, options, addSource, queue }, next) {
+    if ((0, utils_1.isDocumentString)(pointer)) {
+        return queue(() => {
+            const source = (0, utils_1.parseGraphQLSDL)(`${(0, helpers_js_1.stringToHash)(pointer)}.graphql`, pointer, {
+                ...options,
+                ...pointerOptions,
+            });
+            addSource({
+                source,
+                pointer,
+            });
+        });
+    }
+    next();
+}
+function collectCustomLoader({ pointer, pointerOptions, queue, addSource, options, pointerOptionMap }, next) {
+    if (pointerOptions.loader) {
+        return queue(async () => {
+            await Promise.all((0, utils_1.asArray)(pointerOptions.require).map(m => Promise.resolve().then(() => __importStar(require(m)))));
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore TODO options.cwd is possibly undefined, but it seems like no test covers this path
+            const loader = await (0, custom_loader_js_1.useCustomLoader)(pointerOptions.loader, options.cwd);
+            const result = await loader(pointer, { ...options, ...pointerOptions }, pointerOptionMap);
+            if (!result) {
+                return;
+            }
+            addResultOfCustomLoader({ pointer, result, addSource });
+        });
+    }
+    next();
+}
+function collectCustomLoaderSync({ pointer, pointerOptions, queue, addSource, options, pointerOptionMap }, next) {
+    if (pointerOptions.loader) {
+        return queue(() => {
+            const cwdRequire = (0, module_1.createRequire)(options.cwd || (0, process_1.cwd)());
+            for (const m of (0, utils_1.asArray)(pointerOptions.require)) {
+                cwdRequire(m);
+            }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore TODO options.cwd is possibly undefined, but it seems like no test covers this path
+            const loader = (0, custom_loader_js_1.useCustomLoaderSync)(pointerOptions.loader, options.cwd);
+            const result = loader(pointer, { ...options, ...pointerOptions }, pointerOptionMap);
+            if (result) {
+                addResultOfCustomLoader({ pointer, result, addSource });
+            }
+        });
+    }
+    next();
+}
+function collectFallback({ queue, pointer, options, pointerOptions, addSource }) {
+    return queue(async () => {
+        const sources = await (0, load_file_js_1.loadFile)(pointer, {
+            ...options,
+            ...pointerOptions,
+        });
+        if (sources) {
+            for (const source of sources) {
+                addSource({ source, pointer });
+            }
+        }
+    });
+}
+function collectFallbackSync({ queue, pointer, options, pointerOptions, addSource }) {
+    return queue(() => {
+        const sources = (0, load_file_js_1.loadFileSync)(pointer, {
+            ...options,
+            ...pointerOptions,
+        });
+        if (sources) {
+            for (const source of sources) {
+                addSource({ source, pointer });
+            }
+        }
+    });
+}

package/cjs/load-typedefs/load-file.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFileSync = exports.loadFile = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const process_1 = require("process");
+async function loadFile(pointer, options) {
+    var _a;
+    let results = (_a = options.cache) === null || _a === void 0 ? void 0 : _a[pointer];
+    if (!results) {
+        results = [];
+        const errors = [];
+        await Promise.all(options.loaders.map(async (loader) => {
+            try {
+                const loaderResults = await loader.load(pointer, options);
+                loaderResults === null || loaderResults === void 0 ? void 0 : loaderResults.forEach(result => results.push(result));
+            }
+            catch (error) {
+                if (process_1.env['DEBUG']) {
+                    console.error(error);
+                }
+                if (error instanceof utils_1.AggregateError) {
+                    for (const errorElement of error.errors) {
+                        errors.push(errorElement);
+                    }
+                }
+                else {
+                    errors.push(error);
+                }
+            }
+        }));
+        if (results.length === 0 && errors.length > 0) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new utils_1.AggregateError(errors, `Failed to find any GraphQL type definitions in: ${pointer};\n - ${errors
+                .map(error => error.message)
+                .join('\n  - ')}`);
+        }
+        if (options.cache) {
+            options.cache[pointer] = results;
+        }
+    }
+    return results;
+}
+exports.loadFile = loadFile;
+function loadFileSync(pointer, options) {
+    var _a;
+    let results = (_a = options.cache) === null || _a === void 0 ? void 0 : _a[pointer];
+    if (!results) {
+        results = [];
+        const errors = [];
+        for (const loader of options.loaders) {
+            try {
+                // We check for the existence so it is okay to force non null
+                const loaderResults = loader.loadSync(pointer, options);
+                loaderResults === null || loaderResults === void 0 ? void 0 : loaderResults.forEach(result => results.push(result));
+            }
+            catch (error) {
+                if (process_1.env['DEBUG']) {
+                    console.error(error);
+                }
+                if (error instanceof utils_1.AggregateError) {
+                    for (const errorElement of error.errors) {
+                        errors.push(errorElement);
+                    }
+                }
+                else {
+                    errors.push(error);
+                }
+            }
+        }
+        if (results.length === 0 && errors.length > 0) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new utils_1.AggregateError(errors, `Failed to find any GraphQL type definitions in: ${pointer};\n - ${errors
+                .map(error => error.message)
+                .join('\n  - ')}`);
+        }
+        if (options.cache) {
+            options.cache[pointer] = results;
+        }
+    }
+    return results;
+}
+exports.loadFileSync = loadFileSync;

package/cjs/load-typedefs/options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDefaultOptions = void 0;
+const process_1 = require("process");
+function applyDefaultOptions(options) {
+    options.cache = options.cache || {};
+    options.cwd = options.cwd || (0, process_1.cwd)();
+    options.sort = 'sort' in options ? options.sort : true;
+}
+exports.applyDefaultOptions = applyDefaultOptions;

package/cjs/load-typedefs/parse.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSource = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const filter_document_kind_js_1 = require("../filter-document-kind.js");
+function parseSource({ partialSource, options, pointerOptionMap, addValidSource }) {
+    if (partialSource) {
+        const input = prepareInput({
+            source: partialSource,
+            options,
+            pointerOptionMap,
+        });
+        parseSchema(input);
+        parseRawSDL(input);
+        if (input.source.document) {
+            useKindsFilter(input);
+            useComments(input);
+            collectValidSources(input, addValidSource);
+        }
+    }
+}
+exports.parseSource = parseSource;
+//
+function prepareInput({ source, options, pointerOptionMap, }) {
+    let specificOptions = {
+        ...options,
+    };
+    if (source.location) {
+        specificOptions = {
+            ...specificOptions,
+            ...pointerOptionMap[source.location],
+        };
+    }
+    return { source: { ...source }, options: specificOptions };
+}
+function parseSchema(input) {
+    if (input.source.schema) {
+        input.source.rawSDL = (0, utils_1.printSchemaWithDirectives)(input.source.schema, input.options);
+    }
+}
+function parseRawSDL(input) {
+    if (input.source.rawSDL) {
+        input.source.document = (0, utils_1.parseGraphQLSDL)(input.source.location, input.source.rawSDL, input.options).document;
+    }
+}
+function useKindsFilter(input) {
+    if (input.options.filterKinds) {
+        input.source.document = (0, filter_document_kind_js_1.filterKind)(input.source.document, input.options.filterKinds);
+    }
+}
+function useComments(input) {
+    if (!input.source.rawSDL && input.source.document) {
+        input.source.rawSDL = (0, utils_1.printWithComments)(input.source.document);
+        (0, utils_1.resetComments)();
+    }
+}
+function collectValidSources(input, addValidSource) {
+    var _a;
+    if (((_a = input.source.document) === null || _a === void 0 ? void 0 : _a.definitions) && input.source.document.definitions.length > 0) {
+        addValidSource(input.source);
+    }
+}

package/cjs/load-typedefs.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTypedefsSync = exports.loadTypedefs = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const pointers_js_1 = require("./utils/pointers.js");
+const options_js_1 = require("./load-typedefs/options.js");
+const collect_sources_js_1 = require("./load-typedefs/collect-sources.js");
+const parse_js_1 = require("./load-typedefs/parse.js");
+const helpers_js_1 = require("./utils/helpers.js");
+const CONCURRENCY_LIMIT = 100;
+/**
+ * Asynchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * loadTypedefs does not merge the typeDefs when `#import` is used ( https://github.com/ardatan/graphql-tools/issues/2980#issuecomment-1003692728 )
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
+async function loadTypedefs(pointerOrPointers, options) {
+    const { ignore, pointerOptionMap } = (0, pointers_js_1.normalizePointers)(pointerOrPointers);
+    options.ignore = (0, utils_1.asArray)(options.ignore || []);
+    options.ignore.push(...ignore);
+    (0, options_js_1.applyDefaultOptions)(options);
+    const sources = await (0, collect_sources_js_1.collectSources)({
+        pointerOptionMap,
+        options,
+    });
+    const validSources = [];
+    // If we have few k of files it may be an issue
+    const limit = (0, helpers_js_1.useLimit)(CONCURRENCY_LIMIT);
+    await Promise.all(sources.map(partialSource => limit(() => (0, parse_js_1.parseSource)({
+        partialSource,
+        options,
+        pointerOptionMap,
+        addValidSource(source) {
+            validSources.push(source);
+        },
+    }))));
+    return prepareResult({ options, pointerOptionMap, validSources });
+}
+exports.loadTypedefs = loadTypedefs;
+/**
+ * Synchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
+function loadTypedefsSync(pointerOrPointers, options) {
+    const { ignore, pointerOptionMap } = (0, pointers_js_1.normalizePointers)(pointerOrPointers);
+    options.ignore = (0, utils_1.asArray)(options.ignore || []).concat(ignore);
+    (0, options_js_1.applyDefaultOptions)(options);
+    const sources = (0, collect_sources_js_1.collectSourcesSync)({
+        pointerOptionMap,
+        options,
+    });
+    const validSources = [];
+    for (const partialSource of sources) {
+        (0, parse_js_1.parseSource)({
+            partialSource,
+            options,
+            pointerOptionMap,
+            addValidSource(source) {
+                validSources.push(source);
+            },
+        });
+    }
+    return prepareResult({ options, pointerOptionMap, validSources });
+}
+exports.loadTypedefsSync = loadTypedefsSync;
+//
+function prepareResult({ options, pointerOptionMap, validSources, }) {
+    const pointerList = Object.keys(pointerOptionMap);
+    if (pointerList.length > 0 && validSources.length === 0) {
+        throw new Error(`
+      Unable to find any GraphQL type definitions for the following pointers:
+        ${pointerList.map(p => `
+          - ${p}
+          `)}`);
+    }
+    return options.sort
+        ? validSources.sort((left, right) => (0, utils_1.compareStrings)(left.location, right.location))
+        : validSources;
+}

package/cjs/package.json

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

package/cjs/schema.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchemaSync = exports.loadSchema = void 0;
+const load_typedefs_js_1 = require("./load-typedefs.js");
+const graphql_1 = require("graphql");
+const documents_js_1 = require("./documents.js");
+const schema_1 = require("@graphql-tools/schema");
+/**
+ * Asynchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
+async function loadSchema(schemaPointers, options) {
+    var _a, _b;
+    const sources = await (0, load_typedefs_js_1.loadTypedefs)(schemaPointers, {
+        ...options,
+        filterKinds: documents_js_1.OPERATION_KINDS,
+    });
+    const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
+    schemas.push(...((_a = options.schemas) !== null && _a !== void 0 ? _a : []));
+    const mergeSchemasOptions = {
+        ...options,
+        schemas: schemas.concat((_b = options.schemas) !== null && _b !== void 0 ? _b : []),
+        typeDefs,
+    };
+    const schema = (typeDefs === null || typeDefs === void 0 ? void 0 : typeDefs.length) === 0 && (schemas === null || schemas === void 0 ? void 0 : schemas.length) === 1 ? schemas[0] : (0, schema_1.mergeSchemas)(mergeSchemasOptions);
+    if (options === null || options === void 0 ? void 0 : options.includeSources) {
+        includeSources(schema, sources);
+    }
+    return options.sort ? (0, graphql_1.lexicographicSortSchema)(schema) : schema;
+}
+exports.loadSchema = loadSchema;
+/**
+ * Synchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
+function loadSchemaSync(schemaPointers, options) {
+    const sources = (0, load_typedefs_js_1.loadTypedefsSync)(schemaPointers, {
+        filterKinds: documents_js_1.OPERATION_KINDS,
+        ...options,
+    });
+    const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
+    const schema = (0, schema_1.mergeSchemas)({
+        schemas,
+        typeDefs,
+        ...options,
+    });
+    if (options === null || options === void 0 ? void 0 : options.includeSources) {
+        includeSources(schema, sources);
+    }
+    return options.sort ? (0, graphql_1.lexicographicSortSchema)(schema) : schema;
+}
+exports.loadSchemaSync = loadSchemaSync;
+function includeSources(schema, sources) {
+    const finalSources = [];
+    for (const source of sources) {
+        if (source.rawSDL) {
+            finalSources.push(new graphql_1.Source(source.rawSDL, source.location));
+        }
+        else if (source.document) {
+            finalSources.push(new graphql_1.Source((0, graphql_1.print)(source.document), source.location));
+        }
+    }
+    schema.extensions = {
+        ...schema.extensions,
+        sources: finalSources,
+        extendedSources: sources,
+    };
+}
+function collectSchemasAndTypeDefs(sources) {
+    const schemas = [];
+    const typeDefs = [];
+    for (const source of sources) {
+        if (source.schema) {
+            schemas.push(source.schema);
+        }
+        else if (source.document) {
+            typeDefs.push(source.document);
+        }
+    }
+    return {
+        schemas,
+        typeDefs,
+    };
+}

package/cjs/utils/custom-loader.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCustomLoaderSync = exports.useCustomLoader = exports.getCustomLoaderByPath = void 0;
+const module_1 = require("module");
+const path_1 = require("path");
+function getCustomLoaderByPath(path, cwd) {
+    try {
+        const requireFn = (0, module_1.createRequire)((0, path_1.join)(cwd, 'noop.js'));
+        const requiredModule = requireFn(path);
+        if (requiredModule) {
+            if (requiredModule.default && typeof requiredModule.default === 'function') {
+                return requiredModule.default;
+            }
+            if (typeof requiredModule === 'function') {
+                return requiredModule;
+            }
+        }
+    }
+    catch (e) { }
+    return null;
+}
+exports.getCustomLoaderByPath = getCustomLoaderByPath;
+async function useCustomLoader(loaderPointer, cwd) {
+    let loader;
+    if (typeof loaderPointer === 'string') {
+        loader = await getCustomLoaderByPath(loaderPointer, cwd);
+    }
+    else if (typeof loaderPointer === 'function') {
+        loader = loaderPointer;
+    }
+    if (typeof loader !== 'function') {
+        throw new Error(`Failed to load custom loader: ${loaderPointer}`);
+    }
+    return loader;
+}
+exports.useCustomLoader = useCustomLoader;
+function useCustomLoaderSync(loaderPointer, cwd) {
+    let loader;
+    if (typeof loaderPointer === 'string') {
+        loader = getCustomLoaderByPath(loaderPointer, cwd);
+    }
+    else if (typeof loaderPointer === 'function') {
+        loader = loaderPointer;
+    }
+    if (typeof loader !== 'function') {
+        throw new Error(`Failed to load custom loader: ${loaderPointer}`);
+    }
+    return loader;
+}
+exports.useCustomLoaderSync = useCustomLoaderSync;