@eddeee888/gcg-typescript-resolver-files 0.18.0 → 0.18.2

package/src/utils/isWhitelistedModule.spec.ts

@@ -1,71 +0,0 @@
-import { isWhitelistedModule } from './isWhitelistedModule';
-
-describe('isWhitelistedModule()', () => {
-  it.each([
-    {
-      description:
-        'is whitelisted if whitelistedModules and blacklistedModules are empty arrays',
-      moduleName: 'moduleA',
-      whitelistedModules: [],
-      blacklistedModules: [],
-      result: true,
-    },
-    {
-      description: 'is whitelisted if exists in whitelistedModules',
-      moduleName: 'moduleA',
-      whitelistedModules: ['moduleA', 'moduleB'],
-      blacklistedModules: [],
-      result: true,
-    },
-    {
-      description: 'is NOT whitelisted if not exists in whitelistedModules',
-      moduleName: 'moduleA',
-      whitelistedModules: ['moduleB', 'moduleC'],
-      blacklistedModules: [],
-      result: false,
-    },
-    {
-      description:
-        'is whitelisted if exists in whitelistedModules but not blacklistedModules',
-      moduleName: 'moduleB',
-      whitelistedModules: ['moduleB', 'moduleC'],
-      blacklistedModules: ['moduleA'],
-      result: true,
-    },
-    {
-      description:
-        'is whitelisted if whitelistedModules is empty but does not exist in blacklistedModules',
-      moduleName: 'moduleA',
-      whitelistedModules: [],
-      blacklistedModules: ['moduleB'],
-      result: true,
-    },
-    {
-      description:
-        'is NOT whitelisted if exists in both whitelistedModules and blacklistedModules',
-      moduleName: 'moduleA',
-      whitelistedModules: ['moduleA', 'moduleB', 'moduleC'],
-      blacklistedModules: ['moduleA'],
-      result: false,
-    },
-    {
-      description:
-        'is NOT whitelisted if whitelistedModules is empty and exists in blacklistedModules',
-      moduleName: 'moduleA',
-      whitelistedModules: [],
-      blacklistedModules: ['moduleA'],
-      result: false,
-    },
-  ])(
-    '$description',
-    ({ moduleName, blacklistedModules, whitelistedModules, result }) => {
-      expect(result).toEqual(
-        isWhitelistedModule({
-          moduleName,
-          whitelistedModules,
-          blacklistedModules,
-        })
-      );
-    }
-  );
-});

package/src/utils/isWhitelistedModule.ts

@@ -1,21 +0,0 @@
-export const isWhitelistedModule = ({
-  moduleName,
-  whitelistedModules,
-  blacklistedModules,
-}: {
-  moduleName: string;
-  whitelistedModules: string[];
-  blacklistedModules: string[];
-}): boolean => {
-  if (blacklistedModules.includes(moduleName)) {
-    return false;
-  }
-
-  const isInWhitelistedModule =
-    // whitelistedModules is empty a.k.a. all are whitelisted
-    whitelistedModules.length === 0
-      ? true
-      : whitelistedModules.includes(moduleName);
-
-  return isInWhitelistedModule;
-};

package/src/utils/logger.ts

@@ -1,14 +0,0 @@
-import { presetName } from '../preset.js';
-import { fmt } from './fmt.js';
-
-export const logger = {
-  debug: (...args: Parameters<(typeof fmt)['debug']>) => {
-    const debugEnvVar = process.env.DEBUG || '';
-    if (debugEnvVar.includes(presetName)) {
-      console.debug(`\x1b[34m${fmt.debug(...args)}`);
-    }
-  },
-  warn: (...args: Parameters<(typeof fmt)['warn']>) => {
-    console.warn(`\x1b[34m${fmt.warn(...args)}`);
-  },
-};

package/src/utils/normalizeImportExtension.spec.ts

@@ -1,42 +0,0 @@
-import { normalizeImportExtension } from './normalizeImportExtension';
-
-describe('normalizeImportExtension', () => {
-  describe('when importExtension is explicitly provided', () => {
-    it('returns the explicit extension regardless of emitLegacyCommonJSImports', () => {
-      expect(normalizeImportExtension('.js', true)).toBe('.js');
-      expect(normalizeImportExtension('.js', false)).toBe('.js');
-      expect(normalizeImportExtension('.js', undefined)).toBe('.js');
-    });
-
-    it('returns empty string when explicitly set to empty', () => {
-      expect(normalizeImportExtension('', true)).toBe('');
-      expect(normalizeImportExtension('', false)).toBe('');
-      expect(normalizeImportExtension('', undefined)).toBe('');
-    });
-
-    it('returns custom extension formats', () => {
-      expect(normalizeImportExtension('.mjs', undefined)).toBe('.mjs');
-      expect(normalizeImportExtension('.cjs', false)).toBe('.cjs');
-      expect(normalizeImportExtension('.mjs', true)).toBe('.mjs');
-      expect(normalizeImportExtension('.custom.ext')).toBe('.custom.ext');
-    });
-
-    it('takes precedence over emitLegacyCommonJSImports', () => {
-      expect(normalizeImportExtension('.mjs', false)).toBe('.mjs');
-    });
-  });
-
-  describe('when importExtension is undefined', () => {
-    it('returns .js when emitLegacyCommonJSImports is false', () => {
-      expect(normalizeImportExtension(undefined, false)).toBe('.js');
-    });
-
-    it('returns empty string when emitLegacyCommonJSImports is true', () => {
-      expect(normalizeImportExtension(undefined, true)).toBe('');
-    });
-
-    it('returns empty string when emitLegacyCommonJSImports is undefined', () => {
-      expect(normalizeImportExtension(undefined, undefined)).toBe('');
-    });
-  });
-});

package/src/utils/normalizeImportExtension.ts

@@ -1,16 +0,0 @@
-export type ImportExtension = '' | `.${string}`;
-
-export function normalizeImportExtension(
-  importExtension?: ImportExtension,
-  emitLegacyCommonJSImports?: boolean
-): ImportExtension {
-  if (importExtension !== undefined) {
-    return importExtension;
-  }
-
-  if (emitLegacyCommonJSImports !== undefined) {
-    return emitLegacyCommonJSImports ? '' : '.js';
-  }
-
-  return '';
-}

package/src/utils/normalizeRelativePath.ts

@@ -1,6 +0,0 @@
-export const normalizeRelativePath = (path: string): string => {
-  if (!path.startsWith('../') || !path.startsWith('./')) {
-    return `./${path}`;
-  }
-  return path;
-};

package/src/utils/parseLocationForWhitelistedModule.spec.ts

@@ -1,130 +0,0 @@
-import * as path from 'path';
-import {
-  type ParseLocationForWhitelistedModule,
-  parseLocationForWhitelistedModule,
-} from './parseLocationForWhitelistedModule.js';
-import type {
-  ParsedSource,
-  ParseSourcesResult,
-} from '../parseSources/index.js';
-
-const createPartialLocation = (
-  moduleName: string
-): { source: { name: string } } => {
-  return {
-    source: { name: `/path/to/${moduleName}/schema.graphqls` },
-  };
-};
-
-const createParsedSource = (moduleName: string): ParsedSource => {
-  const location = `/path/to/${moduleName}/schema.graphqls`;
-  return {
-    moduleName,
-    relativePathFromBaseToModule: [moduleName],
-    sourcePath: path.parse(location),
-    source: { location: `/path/to/${moduleName}/schema.graphqls` },
-  };
-};
-
-const createSourcesMap = (
-  moduleNames: string[]
-): ParseSourcesResult['sourceMap'] => {
-  return moduleNames.reduce<ParseSourcesResult['sourceMap']>(
-    (res, moduleName) => {
-      const sourceLocation = `/path/to/${moduleName}/schema.graphqls`;
-      res[sourceLocation] = createParsedSource(moduleName);
-      return res;
-    },
-    {}
-  );
-};
-
-describe('parseLocationForWhitelistedModule', () => {
-  test.each([
-    {
-      description:
-        'is whitelisted if whitelistedModules and blacklistedModules are empty arrays',
-      location: createPartialLocation('module1'),
-      sourceMap: createSourcesMap(['module1']),
-      whitelistedModules: [],
-      blacklistedModules: [],
-      result: createParsedSource('module1'),
-    },
-    {
-      description: 'is whitelisted if exists in whitelistedModules',
-      location: createPartialLocation('module2'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: ['module1', 'module2', 'module3'],
-      blacklistedModules: [],
-      result: createParsedSource('module2'),
-    },
-    {
-      description: 'is NOT whitelisted if not exists in whitelistedModules',
-      location: createPartialLocation('module2'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: ['module1', 'module3'],
-      blacklistedModules: [],
-      result: undefined,
-    },
-    {
-      description:
-        'is whitelisted if exists in whitelistedModules but not blacklistedModules',
-      location: createPartialLocation('module2'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: ['module1', 'module2', 'module3'],
-      blacklistedModules: ['module1'],
-      result: createParsedSource('module2'),
-    },
-    {
-      description:
-        'is whitelisted if whitelistedModules is empty but does not exist in blacklistedModules',
-      location: createPartialLocation('module2'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: [],
-      blacklistedModules: ['module1'],
-      result: createParsedSource('module2'),
-    },
-    {
-      description:
-        'is NOT whitelisted if exists in both whitelistedModules and blacklistedModules',
-      location: createPartialLocation('module1'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: ['module1', 'module2', 'module3'],
-      blacklistedModules: ['module1'],
-      result: undefined,
-    },
-    {
-      description:
-        'is NOT whitelisted if whitelistedModules is empty and exists in blacklistedModules',
-      location: createPartialLocation('module3'),
-      sourceMap: createSourcesMap(['module1', 'module2', 'module3']),
-      whitelistedModules: [],
-      blacklistedModules: ['module3'],
-      result: undefined,
-    },
-  ])(
-    '$description',
-    ({ location, sourceMap, blacklistedModules, whitelistedModules, result }) =>
-      expect(
-        parseLocationForWhitelistedModule({
-          location,
-          sourceMap,
-          blacklistedModules,
-          whitelistedModules,
-        } as unknown as ParseLocationForWhitelistedModule)
-      ).toEqual(result)
-  );
-
-  it('throws if location does not exist in sourceMap', () => {
-    expect(() =>
-      parseLocationForWhitelistedModule({
-        location: createPartialLocation('module10'),
-        sourceMap: createSourcesMap(['module1', 'module2']),
-        blacklistedModules: [],
-        whitelistedModules: [],
-      } as unknown as ParseLocationForWhitelistedModule)
-    ).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Unable to find /path/to/module10/schema.graphqls in sourceMap]`
-    );
-  });
-});

package/src/utils/parseLocationForWhitelistedModule.ts

@@ -1,38 +0,0 @@
-import type { Location } from 'graphql';
-import type {
-  ParseSourcesResult,
-  ParsedSource,
-} from '../parseSources/index.js';
-import { isWhitelistedModule } from './isWhitelistedModule.js';
-
-export interface ParseLocationForWhitelistedModule {
-  location: Location | undefined;
-  sourceMap: ParseSourcesResult['sourceMap'];
-  whitelistedModules: string[];
-  blacklistedModules: string[];
-}
-
-export const parseLocationForWhitelistedModule = ({
-  location,
-  sourceMap,
-  whitelistedModules,
-  blacklistedModules,
-}: ParseLocationForWhitelistedModule): ParsedSource | undefined => {
-  if (!location) {
-    throw new Error('Location is invalid');
-  }
-
-  const sourceFilename = location.source.name;
-  const sourceFile = sourceMap[sourceFilename];
-  if (!sourceFile) {
-    throw new Error(`Unable to find ${sourceFilename} in sourceMap`);
-  }
-
-  const isWhitelisted = isWhitelistedModule({
-    moduleName: sourceFile.moduleName,
-    whitelistedModules,
-    blacklistedModules,
-  });
-
-  return isWhitelisted ? sourceFile : undefined;
-};

package/src/utils/printImportLine.spec.ts

@@ -1,150 +0,0 @@
-import { printImportLine } from './printImportLine';
-
-describe('printImportLine', () => {
-  it('prints default import correctly', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: false,
-      namedImports: [],
-      defaultImport: 'DefaultImport',
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe("import  DefaultImport   from './path/to/file';");
-  });
-
-  it('prints one named import correctly', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: false,
-      namedImports: ['Thing'],
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe("import    { Thing } from './path/to/file';");
-  });
-
-  it('prints one aliased named import correctly', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: false,
-      namedImports: [{ propertyName: 'Thing', identifierName: 'OtherThing' }],
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe(
-      "import    { Thing as OtherThing } from './path/to/file';"
-    );
-  });
-
-  it('prints multiple mixed default and named imports correctly', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: false,
-      defaultImport: 'DefaultThing',
-      namedImports: [
-        { propertyName: 'Thing', identifierName: 'OtherThing' },
-        'ThingTwo',
-      ],
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe(
-      "import  DefaultThing , { Thing as OtherThing,ThingTwo } from './path/to/file';"
-    );
-  });
-
-  it('prints .js extension for ESM files', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: false,
-      namedImports: ['Thing'],
-      emitLegacyCommonJSImports: false,
-    });
-    expect(result).toBe("import    { Thing } from './path/to/file.js';");
-  });
-
-  it('does not print .js extension for ESM modules', () => {
-    const result = printImportLine({
-      module: '@org/module',
-      moduleType: 'module',
-      isTypeImport: false,
-      namedImports: ['Thing'],
-      emitLegacyCommonJSImports: false,
-    });
-    expect(result).toBe("import    { Thing } from '@org/module';");
-  });
-
-  it('prints extension as declared', () => {
-    const result = printImportLine({
-      module: 'absolute/path/to/file.js',
-      moduleType: 'preserve',
-      isTypeImport: false,
-      namedImports: ['Thing'],
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe("import    { Thing } from 'absolute/path/to/file.js';");
-  });
-
-  it('prints type import correctly', () => {
-    const result = printImportLine({
-      module: './path/to/file',
-      moduleType: 'file',
-      isTypeImport: true,
-      namedImports: ['Thing'],
-      emitLegacyCommonJSImports: true,
-    });
-    expect(result).toBe("import type   { Thing } from './path/to/file';");
-  });
-
-  describe('importExtension parameter', () => {
-    it('uses explicit importExtension parameter over emitLegacyCommonJSImports', () => {
-      const result = printImportLine({
-        module: './path/to/file',
-        moduleType: 'file',
-        isTypeImport: false,
-        namedImports: ['Thing'],
-        emitLegacyCommonJSImports: false,
-        importExtension: '.mjs',
-      });
-      expect(result).toBe("import    { Thing } from './path/to/file.mjs';");
-    });
-
-    it('uses custom .cjs extension when importExtension is provided', () => {
-      const result = printImportLine({
-        module: './path/to/file',
-        moduleType: 'file',
-        isTypeImport: false,
-        namedImports: ['Thing'],
-        emitLegacyCommonJSImports: true,
-        importExtension: '.cjs',
-      });
-      expect(result).toBe("import    { Thing } from './path/to/file.cjs';");
-    });
-
-    it('uses empty string when importExtension is explicitly set to empty', () => {
-      const result = printImportLine({
-        module: './path/to/file',
-        moduleType: 'file',
-        isTypeImport: false,
-        namedImports: ['Thing'],
-        emitLegacyCommonJSImports: false,
-        importExtension: '',
-      });
-      expect(result).toBe("import    { Thing } from './path/to/file';");
-    });
-
-    it('does not apply importExtension to module imports', () => {
-      const result = printImportLine({
-        module: '@org/module',
-        moduleType: 'module',
-        isTypeImport: false,
-        namedImports: ['Thing'],
-        emitLegacyCommonJSImports: false,
-        importExtension: '.mjs',
-      });
-      expect(result).toBe("import    { Thing } from '@org/module';");
-    });
-  });
-});

package/src/utils/printImportLine.ts

@@ -1,78 +0,0 @@
-import {
-  normalizeImportExtension,
-  type ImportExtension,
-} from './normalizeImportExtension.js';
-
-export interface ImportLineMeta {
-  isTypeImport: boolean;
-  module: string;
-  /**
-   * moduleType
-   *
-   * @description Determines how the module should be treated when imported taking into consideration CJS vs ESM
-   * - file: import is a file. For ESM, .js extension is added. For CJS, no extension is added.
-   * - module: import is a module from `node_modules` or aliased e.g. `graphql-scalars` or `@org/your-module`. No extension is added.
-   * - preserve: preserve what the config declares. This is only used when taking user's config or preset-controlled config e.g. `externalExternals` because the import could be either file or module
-   */
-  moduleType: 'file' | 'module' | 'preserve';
-  namedImports: (string | { propertyName: string; identifierName: string })[];
-  defaultImport?: string;
-  /** @deprecated Use importExtension instead */
-  emitLegacyCommonJSImports: boolean;
-  importExtension?: ImportExtension;
-}
-
-export function printImportLine({
-  isTypeImport,
-  module,
-  moduleType,
-  namedImports,
-  defaultImport,
-  emitLegacyCommonJSImports,
-  importExtension,
-}: ImportLineMeta): string {
-  const typeImportKeyword = isTypeImport ? 'type' : '';
-  const hasDefaultImport = Boolean(defaultImport);
-  const hasNamedImports = namedImports.length > 0;
-  const namedImportsString = hasNamedImports
-    ? `{ ${namedImports.map(printNamedImportSpecifier).join(',')} }`
-    : '';
-
-  let fileExt = '';
-  if (moduleType !== 'preserve') {
-    const isFile = moduleType === 'file';
-    if (isFile) {
-      fileExt = normalizeImportExtension(
-        importExtension,
-        emitLegacyCommonJSImports
-      );
-    }
-  }
-
-  return `import ${typeImportKeyword} ${defaultImport || ''} ${
-    hasDefaultImport && hasNamedImports ? ',' : ''
-  } ${namedImportsString} from '${normalizeModuleExtensionForImport(
-    module
-  )}${fileExt}';`;
-}
-
-const normalizeModuleExtensionForImport = (module: string): string => {
-  if (module.endsWith('.ts')) {
-    return module.split('.').slice(0, -1).join('.');
-  }
-  return module;
-};
-
-const printNamedImportSpecifier = (
-  namedImport: ImportLineMeta['namedImports'][number]
-): string => {
-  if (typeof namedImport === 'string') {
-    return namedImport;
-  }
-
-  if (namedImport.propertyName === namedImport.identifierName) {
-    return namedImport.identifierName;
-  }
-
-  return `${namedImport.propertyName} as ${namedImport.identifierName}`;
-};

package/src/utils/relativeModulePath.ts

@@ -1,7 +0,0 @@
-import * as path from 'path';
-import { normalizeRelativePath } from './normalizeRelativePath.js';
-
-export const relativeModulePath = (from: string, to: string): string => {
-  const rawPath = path.posix.relative(from, to);
-  return normalizeRelativePath(rawPath);
-};

package/src/validateAndMergeParsedConfigs/index.ts

@@ -1 +0,0 @@
-export * from './validateAndMergeParsedConfigs.js';