@depup/graphql-codegen__plugin-helpers 6.2.0-depup.0

package/README.md

@@ -0,0 +1,33 @@
+# @depup/graphql-codegen__plugin-helpers
+
+> Dependency-bumped version of [@graphql-codegen/plugin-helpers](https://www.npmjs.com/package/@graphql-codegen/plugin-helpers)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/graphql-codegen__plugin-helpers
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@graphql-codegen/plugin-helpers](https://www.npmjs.com/package/@graphql-codegen/plugin-helpers) @ 6.2.0 |
+| Processed | 2026-03-17 |
+| Smoke test | passed |
+| Deps updated | 3 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| change-case-all | 1.0.15 | ^2.1.0 |
+| lodash | ~4.17.0 | ^4.17.23 |
+| tslib | ~2.6.0 | ^2.8.1 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@graphql-codegen/plugin-helpers
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,18 @@
+{
+  "bumped": {
+    "change-case-all": {
+      "from": "1.0.15",
+      "to": "^2.1.0"
+    },
+    "lodash": {
+      "from": "~4.17.0",
+      "to": "^4.17.23"
+    },
+    "tslib": {
+      "from": "~2.6.0",
+      "to": "^2.8.1"
+    }
+  },
+  "timestamp": "2026-03-17T16:31:48.947Z",
+  "totalUpdated": 3
+}

package/cjs/federation.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloFederation = exports.federationSpec = void 0;
+exports.addFederationReferencesToSchema = addFederationReferencesToSchema;
+exports.removeFederation = removeFederation;
+const utils_1 = require("@graphql-tools/utils");
+const graphql_1 = require("graphql");
+const index_js_1 = require("./index.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Federation Spec
+ */
+exports.federationSpec = (0, graphql_1.parse)(/* GraphQL */ `
+  scalar _FieldSet
+
+  directive @external on FIELD_DEFINITION
+  directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @key(fields: _FieldSet!) on OBJECT | INTERFACE
+`);
+/**
+ * Adds `__resolveReference` in each ObjectType and InterfaceType involved in Federation.
+ * We do this to utilise the existing FieldDefinition logic of the plugin, which includes many logic:
+ * - mapper
+ * - return type
+ * @param schema
+ */
+function addFederationReferencesToSchema(schema) {
+    const setFederationMeta = ({ meta, typeName, update, }) => {
+        meta[typeName] = {
+            ...(meta[typeName] ||
+                {
+                    hasResolveReference: false,
+                    resolvableKeyDirectives: [],
+                    referenceSelectionSets: [],
+                    referenceSelectionSetsString: '',
+                }),
+            ...update,
+        };
+    };
+    const getReferenceSelectionSets = ({ resolvableKeyDirectives, fields, }) => {
+        const referenceSelectionSets = [];
+        // @key() @key() - "primary keys" in Federation
+        // A reference may receive one primary key combination at a time, so they will be combined with `|`
+        const primaryKeys = resolvableKeyDirectives.map(extractReferenceSelectionSet);
+        referenceSelectionSets.push({ directive: '@key', selectionSets: [...primaryKeys] });
+        const requiresPossibleTypes = [];
+        for (const fieldNode of Object.values(fields)) {
+            // Look for @requires and see what the service needs and gets
+            const directives = getDirectivesByName('requires', fieldNode.astNode);
+            for (const directive of directives) {
+                const requires = extractReferenceSelectionSet(directive);
+                requiresPossibleTypes.push(requires);
+            }
+        }
+        referenceSelectionSets.push({ directive: '@requires', selectionSets: requiresPossibleTypes });
+        return referenceSelectionSets;
+    };
+    /**
+     * Function to find all combinations of selection sets and push them into the `result`
+     * This is used for `@requires` directive because depending on the operation selection set, different
+     * combination of fields are sent from the router.
+     *
+     * @example
+     * Input: [
+     *   { a: true },
+     *   { b: true },
+     *   { c: true },
+     *   { d: true},
+     * ]
+     * Output: [
+     *   { a: true },
+     *   { a: true, b: true },
+     *   { a: true, c: true },
+     *   { a: true, d: true },
+     *   { a: true, b: true, c: true },
+     *   { a: true, b: true, d: true },
+     *   { a: true, c: true, d: true },
+     *   { a: true, b: true, c: true, d: true }
+     *
+     *   { b: true },
+     *   { b: true, c: true },
+     *   { b: true, d: true },
+     *   { b: true, c: true, d: true }
+     *
+     *   { c: true },
+     *   { c: true, d: true },
+     *
+     *   { d: true },
+     * ]
+     * ```
+     */
+    function findAllSelectionSetCombinations(selectionSets, result) {
+        if (selectionSets.length === 0) {
+            return;
+        }
+        for (let baseIndex = 0; baseIndex < selectionSets.length; baseIndex++) {
+            const base = selectionSets.slice(0, baseIndex + 1);
+            const rest = selectionSets.slice(baseIndex + 1, selectionSets.length);
+            const currentSelectionSet = base.reduce((acc, selectionSet) => {
+                acc = { ...acc, ...selectionSet };
+                return acc;
+            }, {});
+            if (baseIndex === 0) {
+                result.push(currentSelectionSet);
+            }
+            for (const selectionSet of rest) {
+                result.push({ ...currentSelectionSet, ...selectionSet });
+            }
+        }
+        const next = selectionSets.slice(1, selectionSets.length);
+        if (next.length > 0) {
+            findAllSelectionSetCombinations(next, result);
+        }
+    }
+    const printReferenceSelectionSets = ({ typeName, baseFederationType, referenceSelectionSets, }) => {
+        const referenceSelectionSetStrings = referenceSelectionSets.reduce((acc, { directive, selectionSets: originalSelectionSets }) => {
+            const result = [];
+            let selectionSets = originalSelectionSets;
+            if (directive === '@requires') {
+                selectionSets = [];
+                findAllSelectionSetCombinations(originalSelectionSets, selectionSets);
+                if (selectionSets.length > 0) {
+                    result.push('Record<PropertyKey, never>');
+                }
+            }
+            for (const referenceSelectionSet of selectionSets) {
+                result.push(`GraphQLRecursivePick<${baseFederationType}, ${JSON.stringify(referenceSelectionSet)}>`);
+            }
+            if (result.length === 0) {
+                return acc;
+            }
+            if (result.length === 1) {
+                acc.push(result.join(' | '));
+                return acc;
+            }
+            acc.push(`( ${result.join('\n        | ')} )`);
+            return acc;
+        }, []);
+        return `\n    ( { __typename: '${typeName}' }\n    & ${referenceSelectionSetStrings.join('\n    & ')} )`;
+    };
+    const federationMeta = {};
+    const transformedSchema = (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.INTERFACE_TYPE]: type => {
+            const node = (0, utils_1.astFromInterfaceType)(type, schema);
+            const federationDetails = checkTypeFederationDetails(node, schema);
+            if (federationDetails && federationDetails.resolvableKeyDirectives.length > 0) {
+                const typeConfig = type.toConfig();
+                typeConfig.fields = {
+                    [resolveReferenceFieldName]: {
+                        type,
+                    },
+                    ...typeConfig.fields,
+                };
+                const referenceSelectionSets = getReferenceSelectionSets({
+                    resolvableKeyDirectives: federationDetails.resolvableKeyDirectives,
+                    fields: typeConfig.fields,
+                });
+                const referenceSelectionSetsString = printReferenceSelectionSets({
+                    typeName: type.name,
+                    baseFederationType: `FederationTypes['${type.name}']`, // FIXME: run convertName on FederationTypes
+                    referenceSelectionSets,
+                });
+                setFederationMeta({
+                    meta: federationMeta,
+                    typeName: type.name,
+                    update: {
+                        hasResolveReference: true,
+                        resolvableKeyDirectives: federationDetails.resolvableKeyDirectives,
+                        referenceSelectionSets,
+                        referenceSelectionSetsString,
+                    },
+                });
+                return new graphql_1.GraphQLInterfaceType(typeConfig);
+            }
+            return type;
+        },
+        [utils_1.MapperKind.OBJECT_TYPE]: type => {
+            const node = (0, utils_1.astFromObjectType)(type, schema);
+            const federationDetails = checkTypeFederationDetails(node, schema);
+            if (federationDetails && federationDetails.resolvableKeyDirectives.length > 0) {
+                const typeConfig = type.toConfig();
+                const referenceSelectionSets = getReferenceSelectionSets({
+                    resolvableKeyDirectives: federationDetails.resolvableKeyDirectives,
+                    fields: typeConfig.fields,
+                });
+                typeConfig.fields = {
+                    [resolveReferenceFieldName]: {
+                        type,
+                    },
+                    ...typeConfig.fields,
+                };
+                const referenceSelectionSetsString = printReferenceSelectionSets({
+                    typeName: type.name,
+                    baseFederationType: `FederationTypes['${type.name}']`, // FIXME: run convertName on FederationTypes
+                    referenceSelectionSets,
+                });
+                setFederationMeta({
+                    meta: federationMeta,
+                    typeName: type.name,
+                    update: {
+                        hasResolveReference: true,
+                        resolvableKeyDirectives: federationDetails.resolvableKeyDirectives,
+                        referenceSelectionSets,
+                        referenceSelectionSetsString,
+                    },
+                });
+                return new graphql_1.GraphQLObjectType(typeConfig);
+            }
+            return type;
+        },
+    });
+    return {
+        transformedSchema,
+        federationMeta,
+    };
+}
+/**
+ * Removes Federation Spec from GraphQL Schema
+ * @param schema
+ * @param config
+ */
+function removeFederation(schema) {
+    return (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.QUERY]: queryType => {
+            const queryTypeConfig = queryType.toConfig();
+            delete queryTypeConfig.fields._entities;
+            delete queryTypeConfig.fields._service;
+            return new graphql_1.GraphQLObjectType(queryTypeConfig);
+        },
+        [utils_1.MapperKind.UNION_TYPE]: unionType => {
+            const unionTypeName = unionType.name;
+            if (unionTypeName === '_Entity' || unionTypeName === '_Any') {
+                return null;
+            }
+            return unionType;
+        },
+        [utils_1.MapperKind.OBJECT_TYPE]: objectType => {
+            if (objectType.name === '_Service') {
+                return null;
+            }
+            return objectType;
+        },
+    });
+}
+const resolveReferenceFieldName = '__resolveReference';
+class ApolloFederation {
+    enabled = false;
+    schema;
+    providesMap;
+    /**
+     * `fieldsToGenerate` is a meta object where the keys are object type names
+     * and the values are fields that must be generated for that object.
+     */
+    fieldsToGenerate;
+    meta = {};
+    constructor({ enabled, schema, meta }) {
+        this.enabled = enabled;
+        this.schema = schema;
+        this.providesMap = this.createMapOfProvides();
+        this.fieldsToGenerate = {};
+        this.meta = meta;
+    }
+    /**
+     * Excludes types definde by Federation
+     * @param typeNames List of type names
+     */
+    filterTypeNames(typeNames) {
+        return this.enabled ? typeNames.filter(t => t !== '_FieldSet') : typeNames;
+    }
+    /**
+     * Excludes `__resolveReference` fields
+     * @param fieldNames List of field names
+     */
+    filterFieldNames(fieldNames) {
+        return this.enabled ? fieldNames.filter(t => t !== resolveReferenceFieldName) : fieldNames;
+    }
+    /**
+     * Decides if directive should not be generated
+     * @param name directive's name
+     */
+    skipDirective(name) {
+        return this.enabled && ['external', 'requires', 'provides', 'key'].includes(name);
+    }
+    /**
+     * Decides if scalar should not be generated
+     * @param name directive's name
+     */
+    skipScalar(name) {
+        return this.enabled && name === '_FieldSet';
+    }
+    /**
+     * findFieldNodesToGenerate
+     * @description Function to find field nodes to generate.
+     * In a normal setup, all fields must be generated.
+     * However, in a Federatin setup, a field should not be generated if:
+     * - The field is marked as `@external` and there is no `@provides` path to the field
+     * - The parent object is marked as `@external` and there is no `@provides` path to the field
+     */
+    findFieldNodesToGenerate({ node, }) {
+        const nodeName = node.name.value;
+        if (this.fieldsToGenerate[nodeName]) {
+            return this.fieldsToGenerate[nodeName];
+        }
+        const fieldNodes = (node.fields || []).map(field => field.node);
+        if (!this.enabled) {
+            return fieldNodes;
+        }
+        // If the object is marked with `@external`, fields to generate are those with `@provides`
+        if (this.isExternal(node)) {
+            const fieldNodesWithProvides = fieldNodes.reduce((acc, fieldNode) => {
+                if (this.hasProvides(node, fieldNode.name.value)) {
+                    acc.push(fieldNode);
+                    return acc;
+                }
+                return acc;
+            }, []);
+            this.fieldsToGenerate[nodeName] = fieldNodesWithProvides;
+            return fieldNodesWithProvides;
+        }
+        // If the object is not marked with `@external`, fields to generate are:
+        // - the fields without `@external`
+        // - the `@external` fields with `@provides`
+        const fieldNodesWithoutExternalOrHasProvides = fieldNodes.reduce((acc, fieldNode) => {
+            if (!this.isExternal(fieldNode)) {
+                acc.push(fieldNode);
+                return acc;
+            }
+            if (this.isExternal(fieldNode) && this.hasProvides(node, fieldNode.name.value)) {
+                acc.push(fieldNode);
+                return acc;
+            }
+            return acc;
+        }, []);
+        this.fieldsToGenerate[nodeName] = fieldNodesWithoutExternalOrHasProvides;
+        return fieldNodesWithoutExternalOrHasProvides;
+    }
+    isResolveReferenceField(fieldNode) {
+        const name = typeof fieldNode.name === 'string' ? fieldNode.name : fieldNode.name.value;
+        return this.enabled && name === resolveReferenceFieldName;
+    }
+    addFederationTypeGenericIfApplicable({ genericTypes, typeName, federationTypesType, }) {
+        if (!this.getMeta()[typeName]) {
+            return;
+        }
+        const typeRef = `${federationTypesType}['${typeName}']`;
+        genericTypes.push(`FederationReferenceType extends ${typeRef} = ${typeRef}`);
+    }
+    getMeta() {
+        return this.meta;
+    }
+    isExternal(node) {
+        return getDirectivesByName('external', node).length > 0;
+    }
+    hasProvides(node, fieldName) {
+        const fields = this.providesMap[node.name.value];
+        if (fields?.length) {
+            return fields.includes(fieldName);
+        }
+        return false;
+    }
+    createMapOfProvides() {
+        const providesMap = {};
+        for (const typename of Object.keys(this.schema.getTypeMap())) {
+            const objectType = this.schema.getType(typename);
+            if ((0, graphql_1.isObjectType)(objectType)) {
+                for (const field of Object.values(objectType.getFields())) {
+                    const provides = getDirectivesByName('provides', field.astNode)
+                        .map(extractReferenceSelectionSet)
+                        .reduce((prev, curr) => [...prev, ...Object.keys(curr)], []); // FIXME: this is not taking into account nested selection sets e.g. `company { taxCode }`
+                    const ofType = (0, utils_js_1.getBaseType)(field.type);
+                    providesMap[ofType.name] ||= [];
+                    providesMap[ofType.name].push(...provides);
+                }
+            }
+        }
+        return providesMap;
+    }
+}
+exports.ApolloFederation = ApolloFederation;
+/**
+ * Checks if Object Type is involved in Federation. Based on `@key` directive
+ * @param node Type
+ */
+function checkTypeFederationDetails(node, schema) {
+    const name = node.name.value;
+    const directives = node.directives;
+    const rootTypeNames = (0, utils_1.getRootTypeNames)(schema);
+    const isNotRoot = !rootTypeNames.has(name);
+    const isNotIntrospection = !name.startsWith('__');
+    const keyDirectives = directives.filter(d => d.name.value === 'key');
+    const check = isNotRoot && isNotIntrospection && keyDirectives.length > 0;
+    if (!check) {
+        return false;
+    }
+    const resolvableKeyDirectives = keyDirectives.filter(d => {
+        for (const arg of d.arguments) {
+            if (arg.name.value === 'resolvable' && arg.value.kind === 'BooleanValue' && arg.value.value === false) {
+                return false;
+            }
+        }
+        return true;
+    });
+    return { resolvableKeyDirectives };
+}
+/**
+ * Extracts directives from a node based on directive's name
+ * @param name directive name
+ * @param node ObjectType or Field
+ */
+function getDirectivesByName(name, node) {
+    return node?.directives?.filter(d => d.name.value === name) || [];
+}
+function extractReferenceSelectionSet(directive) {
+    const arg = directive.arguments.find(arg => arg.name.value === 'fields');
+    const { value } = arg.value;
+    return (0, index_js_1.oldVisit)((0, graphql_1.parse)(`{${value}}`), {
+        leave: {
+            SelectionSet(node) {
+                return node.selections.reduce((accum, field) => {
+                    accum[field.name] = field.selection;
+                    return accum;
+                }, {});
+            },
+            Field(node) {
+                return {
+                    name: node.name.value,
+                    selection: node.selectionSet || true,
+                };
+            },
+            Document(node) {
+                return node.definitions.find((def) => def.kind === 'OperationDefinition' && def.operation === 'query').selectionSet;
+            },
+        },
+    });
+}

package/cjs/getCachedDocumentNodeFromSchema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedDocumentNodeFromSchema = void 0;
+const utils_1 = require("@graphql-tools/utils");
+exports.getCachedDocumentNodeFromSchema = (0, utils_1.memoize1)(utils_1.getDocumentNodeFromSchema);

package/cjs/helpers.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOutputConfigArray = isOutputConfigArray;
+exports.isConfiguredOutput = isConfiguredOutput;
+exports.normalizeOutputParam = normalizeOutputParam;
+exports.normalizeInstanceOrArray = normalizeInstanceOrArray;
+exports.normalizeConfig = normalizeConfig;
+exports.hasNullableTypeRecursively = hasNullableTypeRecursively;
+exports.isUsingTypes = isUsingTypes;
+exports.normalizeImportExtension = normalizeImportExtension;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("./utils.js");
+function isOutputConfigArray(type) {
+    return Array.isArray(type);
+}
+function isConfiguredOutput(type) {
+    return typeof type === 'object';
+}
+function normalizeOutputParam(config) {
+    // In case of direct array with a list of plugins
+    if (isOutputConfigArray(config)) {
+        return {
+            documents: [],
+            schema: [],
+            plugins: isConfiguredOutput(config) ? config.plugins : config,
+        };
+    }
+    if (isConfiguredOutput(config)) {
+        return config;
+    }
+    throw new Error(`Invalid "generates" config!`);
+}
+function normalizeInstanceOrArray(type) {
+    if (Array.isArray(type)) {
+        return type;
+    }
+    if (!type) {
+        return [];
+    }
+    return [type];
+}
+function normalizeConfig(config) {
+    if (typeof config === 'string') {
+        return [{ [config]: {} }];
+    }
+    if (Array.isArray(config)) {
+        return config.map(plugin => (typeof plugin === 'string' ? { [plugin]: {} } : plugin));
+    }
+    if (typeof config === 'object') {
+        return Object.keys(config).reduce((prev, pluginName) => [...prev, { [pluginName]: config[pluginName] }], []);
+    }
+    return [];
+}
+function hasNullableTypeRecursively(type) {
+    if (!(0, graphql_1.isNonNullType)(type)) {
+        return true;
+    }
+    if ((0, graphql_1.isListType)(type) || (0, graphql_1.isNonNullType)(type)) {
+        return hasNullableTypeRecursively(type.ofType);
+    }
+    return false;
+}
+function isUsingTypes(document, externalFragments, schema) {
+    let foundFields = 0;
+    const typesStack = [];
+    (0, graphql_1.visit)(document, {
+        SelectionSet: {
+            enter(node, key, parent, anscestors) {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    const nextTypeName = (() => {
+                        if (parent.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                            return parent.typeCondition.name.value;
+                        }
+                        if (parent.kind === graphql_1.Kind.FIELD) {
+                            const lastType = typesStack[typesStack.length - 1];
+                            if (!lastType) {
+                                throw new Error(`Unable to find parent type! Please make sure you operation passes validation`);
+                            }
+                            const field = lastType.getFields()[parent.name.value];
+                            if (!field) {
+                                throw new Error(`Unable to find field "${parent.name.value}" on type "${lastType}"!`);
+                            }
+                            return (0, utils_js_1.getBaseType)(field.type).name;
+                        }
+                        if (parent.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+                            if (parent.operation === 'query') {
+                                return schema.getQueryType().name;
+                            }
+                            if (parent.operation === 'mutation') {
+                                return schema.getMutationType().name;
+                            }
+                            if (parent.operation === 'subscription') {
+                                return schema.getSubscriptionType().name;
+                            }
+                        }
+                        else if (parent.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+                            if (parent.typeCondition) {
+                                return parent.typeCondition.name.value;
+                            }
+                            return typesStack[typesStack.length - 1].name;
+                        }
+                        return null;
+                    })();
+                    typesStack.push(schema.getType(nextTypeName));
+                }
+            },
+            leave(node) {
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    typesStack.pop();
+                }
+            },
+        },
+        Field: {
+            enter: (node, key, parent, path, anscestors) => {
+                if (node.name.value.startsWith('__')) {
+                    return;
+                }
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selectionSet ? node.selectionSet.selections || [] : [];
+                const relevantFragmentSpreads = selections.filter(s => s.kind === graphql_1.Kind.FRAGMENT_SPREAD && !externalFragments.includes(s.name.value));
+                if (selections.length === 0 || relevantFragmentSpreads.length > 0) {
+                    foundFields++;
+                }
+                if (schema) {
+                    const lastType = typesStack[typesStack.length - 1];
+                    if (lastType && (0, graphql_1.isObjectType)(lastType)) {
+                        const field = lastType.getFields()[node.name.value];
+                        if (!field) {
+                            throw new Error(`Unable to find field "${node.name.value}" on type "${lastType}"!`);
+                        }
+                        const currentType = field.type;
+                        // To handle `Maybe` usage
+                        if (hasNullableTypeRecursively(currentType)) {
+                            foundFields++;
+                        }
+                    }
+                }
+            },
+        },
+        VariableDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+        InputValueDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+    });
+    return foundFields > 0;
+}
+function normalizeImportExtension({ emitLegacyCommonJSImports, importExtension, }) {
+    if (importExtension !== undefined) {
+        return importExtension;
+    }
+    if (emitLegacyCommonJSImports === undefined || emitLegacyCommonJSImports === true) {
+        return '';
+    }
+    return '.js';
+}

package/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExternalModuleAndFn = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./federation.js"), exports);
+tslib_1.__exportStar(require("./getCachedDocumentNodeFromSchema.js"), exports);
+tslib_1.__exportStar(require("./helpers.js"), exports);
+tslib_1.__exportStar(require("./oldVisit.js"), exports);
+tslib_1.__exportStar(require("./profiler.js"), exports);
+var resolve_external_module_and_fn_js_1 = require("./resolve-external-module-and-fn.js");
+Object.defineProperty(exports, "resolveExternalModuleAndFn", { enumerable: true, get: function () { return resolve_external_module_and_fn_js_1.resolveExternalModuleAndFn; } });
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);