@teambit/typescript 1.0.108 → 1.0.110

package/typescript.main.runtime.ts

@@ -1,442 +0,0 @@
-import ts from 'typescript';
-import { Slot, SlotRegistry } from '@teambit/harmony';
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { Compiler } from '@teambit/compiler';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import { SchemaAspect, SchemaExtractor, SchemaMain } from '@teambit/schema';
-import { PackageJsonProps } from '@teambit/pkg';
-import { TypescriptConfigMutator } from '@teambit/typescript.modules.ts-config-mutator';
-import { WorkspaceAspect } from '@teambit/workspace';
-import type { Workspace } from '@teambit/workspace';
-import { DependencyResolverAspect, DependencyResolverMain } from '@teambit/dependency-resolver';
-import pMapSeries from 'p-map-series';
-import { TsserverClient, TsserverClientOpts } from '@teambit/ts-server';
-import AspectLoaderAspect, { AspectLoaderMain } from '@teambit/aspect-loader';
-import WatcherAspect, { WatcherMain, WatchOptions } from '@teambit/watcher';
-import type { Component, ComponentID } from '@teambit/component';
-import { BuilderAspect, BuilderMain } from '@teambit/builder';
-import EnvsAspect, { EnvsMain } from '@teambit/envs';
-import { ScopeMain, ScopeAspect } from '@teambit/scope';
-import { TypeScriptExtractor } from './typescript.extractor';
-import { TypeScriptCompilerOptions } from './compiler-options';
-import { TypescriptAspect } from './typescript.aspect';
-import { TypescriptCompiler } from './typescript.compiler';
-import { TypeScriptParser } from './typescript.parser';
-import { SchemaNodeTransformer, SchemaTransformer } from './schema-transformer';
-import { SchemaTransformerPlugin } from './schema-transformer.plugin';
-import {
-  ExportDeclarationTransformer,
-  TypeAliasTransformer,
-  FunctionLikeTransformer,
-  SetAccessorTransformer,
-  GetAccessorTransformer,
-  IndexSignatureTransformer,
-  PropertyDeclarationTransformer,
-  ParameterTransformer,
-  VariableStatementTransformer,
-  VariableDeclaration,
-  SourceFileTransformer,
-  ClassDeclarationTransformer,
-  InterfaceDeclarationTransformer,
-  EnumDeclarationTransformer,
-  BindingElementTransformer,
-  ExportAssignmentTransformer,
-  ImportDeclarationTransformer,
-  IntersectionTypeTransformer,
-  UnionTypeTransformer,
-  TypeReferenceTransformer,
-  TypeLiteralTransformer,
-  LiteralTypeTransformer,
-  TypeQueryTransformer,
-  ArrayTypeTransformer,
-  TypeOperatorTransformer,
-  KeywordTypeTransformer,
-  TupleTypeTransformer,
-  ParenthesizedTypeTransformer,
-  TypePredicateTransformer,
-  IndexedAccessTypeTransformer,
-  TemplateLiteralTypeSpanTransformer,
-  TemplateLiteralTypeTransformer,
-  ThisTypeTransformer,
-  ConditionalTypeTransformer,
-  NamedTupleTransformer,
-  ConstructorTransformer,
-  ExpressionStatementTransformer,
-  ModuleDeclarationTransformer,
-} from './transformers';
-import { CheckTypesCmd } from './cmds/check-types.cmd';
-import { TsconfigPathsPerEnv, TsconfigWriter } from './tsconfig-writer';
-import WriteTsconfigCmd from './cmds/write-tsconfig.cmd';
-import { RemoveTypesTask } from './remove-types-task';
-
-export type TsMode = 'build' | 'dev';
-
-export type SchemaTransformerSlot = SlotRegistry<SchemaTransformer[]>;
-export type APITransformerSlot = SlotRegistry<SchemaNodeTransformer[]>;
-
-export type TsConfigTransformContext = {
-  // mode: TsMode;
-};
-
-export type TsconfigWriterOptions = {
-  clean?: boolean;
-  silent?: boolean; // no prompt
-  dedupe?: boolean;
-  dryRun?: boolean;
-  dryRunWithTsconfig?: boolean;
-};
-
-export type TsConfigTransformer = (
-  config: TypescriptConfigMutator,
-  context: TsConfigTransformContext
-) => TypescriptConfigMutator;
-
-export class TypescriptMain {
-  constructor(
-    private logger: Logger,
-    readonly schemaTransformerSlot: SchemaTransformerSlot,
-    readonly apiTransformerSlot: APITransformerSlot,
-    readonly workspace: Workspace,
-    readonly scope: ScopeMain,
-    readonly depResolver: DependencyResolverMain,
-    private envs: EnvsMain,
-    private tsConfigWriter: TsconfigWriter,
-    private aspectLoader: AspectLoaderMain
-  ) {}
-
-  private tsServer: TsserverClient;
-  /**
-   * create a new compiler.
-   */
-  createCompiler(
-    options: TypeScriptCompilerOptions,
-    transformers: TsConfigTransformer[] = [],
-    tsModule = ts
-  ): Compiler {
-    const configMutator = new TypescriptConfigMutator(options);
-    const transformerContext: TsConfigTransformContext = {};
-    const afterMutation = runTransformersWithContext(configMutator.clone(), transformers, transformerContext);
-    return new TypescriptCompiler(TypescriptAspect.id, this.logger, afterMutation.raw, tsModule);
-  }
-
-  /**
-   * get TsserverClient instance if initiated already, otherwise, return undefined.
-   */
-  getTsserverClient(): TsserverClient | undefined {
-    return this.tsServer;
-  }
-
-  registerSchemaTransformer(transformers: SchemaTransformer[]) {
-    this.schemaTransformerSlot.register(transformers);
-    return this;
-  }
-
-  registerApiTransformer(transformers: SchemaNodeTransformer[]) {
-    this.apiTransformerSlot.register(transformers);
-    return this;
-  }
-
-  /**
-   * starts a tsserver process to communicate with its API.
-   * @param projectPath absolute path of the project root directory
-   * @param options TsserverClientOpts
-   * @param files optionally, if check-types is enabled, provide files to open and type check.
-   * @returns TsserverClient
-   */
-  async initTsserverClient(
-    projectPath: string,
-    options: TsserverClientOpts = {},
-    files: string[] = []
-  ): Promise<TsserverClient> {
-    this.tsServer = new TsserverClient(projectPath, this.logger, options, files);
-    await this.tsServer.init();
-    return this.tsServer;
-  }
-
-  /**
-   * starts a tsserver process to communicate with its API. use only when running on the workspace.
-   * @param options TsserverClientOpts
-   * @param files optionally, if check-types is enabled, provide files to open and type check.
-   * @returns TsserverClient
-   */
-  async initTsserverClientFromWorkspace(
-    options: TsserverClientOpts = {},
-    files: string[] = []
-  ): Promise<TsserverClient> {
-    if (!this.workspace) {
-      throw new Error(`initTsserverClientFromWorkspace: workspace was not found`);
-    }
-    return this.initTsserverClient(this.workspace.path, options, files);
-  }
-
-  /**
-   * Create a compiler instance and run the cjs transformer for it
-   * @param options
-   * @param transformers
-   * @param tsModule
-   * @returns
-   */
-  createCjsCompiler(options: TypeScriptCompilerOptions, transformers: TsConfigTransformer[] = [], tsModule = ts) {
-    return this.createCompiler(options, [this.getCjsTransformer(), ...transformers], tsModule);
-  }
-
-  /**
-   * Create a compiler instance and run the esm transformer for it
-   * @param options
-   * @param transformers
-   * @param tsModule
-   * @returns
-   */
-  createEsmCompiler(options: TypeScriptCompilerOptions, transformers: TsConfigTransformer[] = [], tsModule = ts) {
-    return this.createCompiler(options, [this.getEsmTransformer(), ...transformers], tsModule);
-  }
-
-  /**
-   * Create a transformer that change the ts module to CommonJS
-   * @returns
-   */
-  getCjsTransformer(): TsConfigTransformer {
-    const cjsTransformer = (config: TypescriptConfigMutator) => {
-      config.setModule('CommonJS');
-      return config;
-    };
-    return cjsTransformer;
-  }
-
-  /**
-   * Create a transformer that change the ts module to ES2020
-   * @returns
-   */
-  getEsmTransformer(): TsConfigTransformer {
-    const esmTransformer = (config: TypescriptConfigMutator) => {
-      config.setTarget('ES2017');
-      config.raw.tsconfig.compilerOptions.module = 'es2020';
-      config.raw.tsconfig.compilerOptions.lib = ['es2021', 'dom', 'ESNext.String', 'dom.Iterable'];
-      return config;
-    };
-    return esmTransformer;
-  }
-
-  /**
-   * create an instance of a typescript semantic schema extractor.
-   */
-  createSchemaExtractor(tsconfig: any, tsserverPath?: string, contextPath?: string): SchemaExtractor {
-    return new TypeScriptExtractor(
-      tsconfig,
-      this.schemaTransformerSlot,
-      this.apiTransformerSlot,
-      this,
-      tsserverPath || this.workspace?.path || '',
-      contextPath || this.workspace?.path || '',
-      this.depResolver,
-      this.workspace,
-      this.scope,
-      this.aspectLoader,
-      this.logger
-    );
-  }
-
-  /**
-   * add the default package json properties to the component
-   * :TODO @gilad why do we need this DSL? can't I just get the args here.
-   */
-  getCjsPackageJsonProps(): PackageJsonProps {
-    return {
-      main: 'dist/{main}.js',
-      types: '{main}.ts',
-    };
-  }
-
-  /**
-   * add type: module to the package.json props and the default props
-   * :TODO @gilad why do we need this DSL? can't I just get the args here.
-   */
-  getEsmPackageJsonProps(): PackageJsonProps {
-    return {
-      // main: 'dist-esm/{main}.js',
-      main: 'dist/{main}.js',
-      type: 'module',
-      types: '{main}.ts',
-    };
-  }
-
-  getSupportedFilesForTsserver(components: Component[]): string[] {
-    const files = components
-      .map((c) => c.filesystem.files)
-      .flat()
-      .map((f) => f.path);
-    return files.filter((f) => f.endsWith('.ts') || f.endsWith('.tsx'));
-  }
-
-  async cleanTsconfigJson(options: TsconfigWriterOptions = {}) {
-    const components = await this.workspace.list();
-    const runtime = await this.envs.createEnvironment(components);
-    const execContext = runtime.getEnvExecutionContext();
-
-    const results = await new TsconfigWriter(this.workspace, this.logger).clean(execContext, options);
-
-    return results;
-  }
-
-  async writeTsconfigJson(options: TsconfigWriterOptions = {}): Promise<{
-    cleanResults?: string[];
-    writeResults: TsconfigPathsPerEnv[];
-  }> {
-    const components = await this.workspace.list();
-    const runtime = await this.envs.createEnvironment(components);
-    const execContext = runtime.getEnvExecutionContext();
-
-    let cleanResults: string[] | undefined;
-    if (options.clean) {
-      cleanResults = await this.tsConfigWriter.clean(execContext, options);
-    }
-
-    const writeResults = await this.tsConfigWriter.write(execContext, options);
-
-    return { writeResults, cleanResults };
-  }
-
-  private async onPreWatch(componentIds: ComponentID[], watchOpts: WatchOptions) {
-    const workspace = this.workspace;
-    if (!workspace || !watchOpts.spawnTSServer) {
-      return;
-    }
-    const { verbose, checkTypes } = watchOpts;
-    const files = checkTypes ? this.getSupportedFilesForTsserver(await workspace.getMany(componentIds)) : [];
-    const printTypeErrors = Boolean(checkTypes);
-    await this.initTsserverClientFromWorkspace({ verbose, checkTypes, printTypeErrors }, files);
-  }
-
-  private async onComponentChange(component: Component, files: string[]) {
-    if (!this.tsServer) {
-      return {
-        results: 'N/A',
-      };
-    }
-    await pMapSeries(files, (file) => this.tsServer.onFileChange(file));
-    return {
-      results: 'succeed',
-    };
-  }
-
-  static runtime = MainRuntime;
-  static dependencies = [
-    SchemaAspect,
-    LoggerAspect,
-    AspectLoaderAspect,
-    WorkspaceAspect,
-    CLIAspect,
-    DependencyResolverAspect,
-    EnvsAspect,
-    WatcherAspect,
-    ScopeAspect,
-    BuilderAspect,
-  ];
-  static slots = [Slot.withType<SchemaTransformer[]>(), Slot.withType<SchemaNodeTransformer[]>()];
-
-  static async provider(
-    [schema, loggerExt, aspectLoader, workspace, cli, depResolver, envs, watcher, scope, builder]: [
-      SchemaMain,
-      LoggerMain,
-      AspectLoaderMain,
-      Workspace,
-      CLIMain,
-      DependencyResolverMain,
-      EnvsMain,
-      WatcherMain,
-      ScopeMain,
-      BuilderMain
-    ],
-    config,
-    [schemaTransformerSlot, apiTransformerSlot]: [SchemaTransformerSlot, APITransformerSlot]
-  ) {
-    schema.registerParser(new TypeScriptParser());
-    const logger = loggerExt.createLogger(TypescriptAspect.id);
-
-    aspectLoader.registerPlugins([new SchemaTransformerPlugin(schemaTransformerSlot)]);
-    const tsconfigWriter = new TsconfigWriter(workspace, logger);
-    const tsMain = new TypescriptMain(
-      logger,
-      schemaTransformerSlot,
-      apiTransformerSlot,
-      workspace,
-      scope,
-      depResolver,
-      envs,
-      tsconfigWriter,
-      aspectLoader
-    );
-    tsMain.registerSchemaTransformer([
-      new ExportDeclarationTransformer(),
-      new ExportAssignmentTransformer(),
-      new FunctionLikeTransformer(),
-      new ParameterTransformer(),
-      new SetAccessorTransformer(),
-      new GetAccessorTransformer(),
-      new IndexSignatureTransformer(),
-      new PropertyDeclarationTransformer(),
-      new VariableStatementTransformer(),
-      new VariableDeclaration(),
-      new SourceFileTransformer(),
-      new TypeAliasTransformer(),
-      new ClassDeclarationTransformer(),
-      new InterfaceDeclarationTransformer(),
-      new EnumDeclarationTransformer(),
-      new BindingElementTransformer(),
-      new IntersectionTypeTransformer(),
-      new UnionTypeTransformer(),
-      new TypeReferenceTransformer(),
-      new TypeLiteralTransformer(),
-      new LiteralTypeTransformer(),
-      new TypeQueryTransformer(),
-      new ArrayTypeTransformer(),
-      new TypeOperatorTransformer(),
-      new KeywordTypeTransformer(),
-      new TupleTypeTransformer(),
-      new ParenthesizedTypeTransformer(),
-      new TypePredicateTransformer(),
-      new IndexedAccessTypeTransformer(),
-      new TemplateLiteralTypeSpanTransformer(),
-      new TemplateLiteralTypeTransformer(),
-      new ThisTypeTransformer(),
-      new ConditionalTypeTransformer(),
-      new NamedTupleTransformer(),
-      new ConstructorTransformer(),
-      new ImportDeclarationTransformer(),
-      new ExpressionStatementTransformer(),
-      new ModuleDeclarationTransformer(),
-    ]);
-
-    if (workspace) {
-      watcher.registerOnPreWatch(tsMain.onPreWatch.bind(tsMain));
-      workspace.registerOnComponentChange(tsMain.onComponentChange.bind(tsMain));
-      workspace.registerOnComponentAdd(tsMain.onComponentChange.bind(tsMain));
-    }
-
-    const removeTypesTask = new RemoveTypesTask();
-    builder.registerSnapTasks([removeTypesTask]);
-    builder.registerTagTasks([removeTypesTask]);
-
-    const checkTypesCmd = new CheckTypesCmd(tsMain, workspace, logger);
-    const writeTsconfigCmd = new WriteTsconfigCmd(tsMain);
-    cli.register(checkTypesCmd, writeTsconfigCmd);
-
-    return tsMain;
-  }
-}
-
-TypescriptAspect.addRuntime(TypescriptMain);
-
-export function runTransformersWithContext(
-  config: TypescriptConfigMutator,
-  transformers: TsConfigTransformer[] = [],
-  context: TsConfigTransformContext
-): TypescriptConfigMutator {
-  if (!Array.isArray(transformers)) return config;
-  const newConfig = transformers.reduce((acc, transformer) => {
-    return transformer(acc, context);
-  }, config);
-  return newConfig;
-}
-
-export default TypescriptMain;

package/typescript.parser.spec.ts

@@ -1,221 +0,0 @@
-import ts from 'typescript';
-import { expect } from 'chai';
-
-import { TypeScriptParser } from './typescript.parser';
-
-describe('TypescriptParser', () => {
-  describe('getExports', () => {
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export
-    // https://www.typescriptlang.org/docs/handbook/modules.html#export
-
-    const exampleArrowFunction = `
-      export const arrow = () => { return 3; }
-      arrow.textProperty = "propertyValue";
-    `;
-
-    const exampleFunction = `
-      export function func() { return 3; }
-      func.textProperty = "propertyValue";
-    `;
-
-    const exampleClass = `
-      export class classy{ render() { return 3; } }
-      classy.textProperty = "propertyValue";
-    `;
-
-    const exampleStatement = `
-      function myFunction2 () { return 3; }
-      const myVariable2 = 3;
-      export { myFunction2, myVariable2 };
-    `;
-
-    const exampleRenamedStatement = `
-      function myFunction2 () { return 3; }
-      const myVariable2 = 3;
-      export { myFunction2, myVariable2 as myVariable2Alias };
-    `;
-
-    const exampleReExport = `
-      export { default as function1, function2 } from "bar.js";
-    `;
-
-    const exampleReExportDefault = `
-      export { default, function2 } from "bar.js";
-    `;
-
-    const exampleRenamedReExportAll = `
-      export * as ns from "mod";
-    `;
-
-    const exampleExportDefault = `
-      const a: number = 1
-      export default { a };
-    `;
-
-    it('should parse arrowFunctions', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleArrowFunction, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportArrow = exports.find((x) => x.identifier === 'arrow');
-
-      expect(exportArrow).to.exist;
-    });
-
-    it('should parse function exports', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFunction, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction = exports.find((x) => x.identifier === 'func');
-
-      expect(exportFunction).to.exist;
-    });
-
-    it('should parse classes', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleClass, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportClass = exports.find((x) => x.identifier === 'classy');
-
-      expect(exportClass).to.exist;
-    });
-
-    it('should parse declarations', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleStatement, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction = exports.find((x) => x.identifier === 'myFunction2');
-      const exportVariable = exports.find((x) => x.identifier === 'myVariable2');
-
-      expect(exportFunction).to.exist;
-      expect(exportVariable).to.exist;
-    });
-
-    it('should parse renamed declarations', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleRenamedStatement, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction = exports.find((x) => x.identifier === 'myFunction2');
-      const exportVariable = exports.find((x) => x.identifier === 'myVariable2Alias');
-
-      expect(exportFunction).to.exist;
-      expect(exportVariable).to.exist;
-    });
-
-    it('should parse re-exports', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleReExport, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction1 = exports.find((x) => x.identifier === 'function1');
-      const exportFunction2 = exports.find((x) => x.identifier === 'function2');
-
-      expect(exportFunction1).to.exist;
-      expect(exportFunction2).to.exist;
-    });
-
-    it('should parse re-exports with default', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleReExportDefault, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction1 = exports.find((x) => x.identifier === 'default');
-      const exportFunction2 = exports.find((x) => x.identifier === 'function2');
-
-      expect(exportFunction1).not.to.exist;
-      expect(exportFunction2).to.exist;
-    });
-
-    it('should parse renamed re-exports all', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleRenamedReExportAll, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction1 = exports.find((x) => x.identifier === 'ns');
-
-      expect(exportFunction1).to.exist;
-    });
-
-    it('should parse default exports', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleExportDefault, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      expect(exports.length).to.equal(0);
-    });
-
-    describe('staticProperties', () => {
-      it('should include staticProperties, when on arrowFunctions', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleArrowFunction, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportArrow = exports.find((x) => x.identifier === 'arrow');
-
-        expect(exportArrow?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-
-      it('should include staticProperties, when on regular functions', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleFunction, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportClass = exports.find((x) => x.identifier === 'func');
-
-        expect(exportClass?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-
-      it('should include staticProperties, when on classes', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleClass, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportClass = exports.find((x) => x.identifier === 'classy');
-
-        expect(exportClass?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-    });
-  });
-
-  describe('collectStaticProperties', () => {
-    const exampleFile = `
-      export const hello = () => { return 3; }
-
-      hello.text = "is";
-      hello.count = 3;
-      hello.nullish = null;
-      hello.undef = undefined;
-      hello.disable = false;
-      hello.enable = true;
-      hello.complextLiteral = \`what \${hello.text} it?\`;
-      hello.nonAssignedProperty += 'value';
-    `;
-
-    it('should parse all primitive values', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-
-      expect(staticProperties).to.exist;
-
-      const exportHello = staticProperties.get('hello');
-      expect(exportHello).to.exist;
-
-      expect(exportHello?.get('text')).to.equal('is');
-      expect(exportHello?.get('count')).to.equal(3);
-      expect(exportHello?.get('nullish')).to.equal(null);
-      expect(exportHello?.get('undef')).to.equal(undefined);
-      expect(exportHello?.get('disable')).to.equal(false);
-      expect(exportHello?.get('enable')).to.equal(true);
-
-      expect(exportHello?.has('complextLiteral')).to.be.false;
-    });
-
-    it('should skip non primitive values', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-      const exportHello = staticProperties.get('hello');
-
-      expect(exportHello?.has('complextLiteral')).to.be.false;
-    });
-
-    it('should skip non assignment statements', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-      const exportHello = staticProperties.get('hello');
-
-      expect(exportHello?.has('nonAssignedProperty')).to.be.false;
-    });
-  });
-});