[RFC] Resolve circular reference of imports

[4513ECHO]

WIP

Need to discuss:

• Should we stop re-exporting Base* classes and Base*Params types from types.ts?
• Should we move definitions of Base*Params types to types.ts and import them from base/*.ts?

Current dependencies graph:

[Shougo]

Should we stop re-exporting Base* classes and Base*Params types from types.ts?

It should.

Should we move definitions of BaseParams types to types.ts and import them from base/.ts?

It should not.

Because base/*.ts files are already exported.

[4513ECHO]

We have stopped re-exporting, but the problem continues to persist.
types.ts defines User{Column,Fiter,Source,Ui which depends on Base{Column,Filter,Source,Ui}Params, so we cannot make types.ts independent.
To solve the problem we have to define Base*Params in types.ts in the same way that we do BaseActionParams in types.ts.

[Shougo]

Hm... If so, User{Column, Filer, Source, Ui} should be exported in base/*.ts files.

[4513ECHO]

Oh, I have found DduOptions also depends on Base*Params.
Is there any way to keep DduOptions in types.ts other than defining Base*Params and User* in types.ts?

export type DduOptions = {
  // ...
  columnParams: Record<ColumnName, Partial<BaseColumnParams>>;
  filterParams: Record<FilterName, Partial<BaseFilterParams>>;
  kindParams: Record<KindName, Partial<BaseKindParams>>;
  // ...
  postFilters: UserFilter[];
  sourceParams: Record<SourceName, Partial<BaseSourceParams>>;
  sources: UserSource[];
  // ...
  uiParams: Record<UiName, Partial<BaseUiParams>>;
};

[Shougo]

DduOptions must be defined in types.ts.

Hm...

Base*Params can be defined as BaseParams in types.ts.
Because it is just Record<string, unknown>.

[4513ECHO]

Remaining circular reference:

• ddu.ts and types.ts
• context.ts and types.ts
• loader.ts and base/source.ts

[4513ECHO]

I think the following way is better to resolve a circular reference between loader.ts and base/source/ts:
I've tried, but Loader depends on Base* classes so the way is impossible...

1. Define Loader interface in types.ts.

export interface Loader {
  initStaticImportPath(denops: Denops): Promise<void>;
  autoload(denops: Denops, type: DduExtType, name: string): Promise<void>;
  registerAlias(type: DduAliasType, alias: string, base: string): void;
  registerPath(type: DduExtType, path: string): Promise<void>;
  getUi(index: string, name: string): BaseUi<BaseParams> | null;
  getSource(index: string, name: string): BaseSource<BaseParams> | null;
  getFilter(index: string, name: string): BaseFilter<BaseParams> | null;
  getKind(index: string, name: string): BaseKind<BaseParams> | null;
  getColumn(index: string, name: string): BaseColumn<BaseParams> | null;
  getAlias(type: DduAliasType, name: string): string | undefined;
  getAliasNames(type: DduAliasType): string[];
  getSourceNames(): string[];
}

2. Implement the interface in loader.ts.

import type { Loader } from "./types.ts";

export class LoaderImpl implements Loader {
  // ...
}

3. Import Loader from types.ts in base/source.ts.

[Shougo]

context.ts and types.ts

Hm.

export { ContextBuilder } from "./context.ts";

can be removed in types.ts.

ddu.ts and types.ts

export type { Ddu } from "./ddu.ts";

can be removed in types.ts

NOTE: Both ddu.ts and context.ts must be exported.

[Shougo]

loader.ts and base/source.ts

Hm...

loader.ts is only used for the arguments.

export type OnInitArguments<Params extends BaseSourceParams> = {
  denops: Denops;
  sourceOptions: SourceOptions;
  sourceParams: Params;
  loader: Loader;
};

export type OnEventArguments<Params extends BaseSourceParams> = {
  denops: Denops;
  sourceOptions: SourceOptions;
  sourceParams: Params;
  event: DduEvent;
};

export type GatherArguments<Params extends BaseSourceParams> = {
  denops: Denops;
  context: Context;
  options: DduOptions;
  sourceOptions: SourceOptions;
  sourceParams: Params;
  input: string;
  parent?: DduItem;
  loader: Loader;
};

You can split the file.

[Shougo]

Why base/source.ts requires loader?
Because some sources uses loader...

[Shougo]

https://github.com/4513ECHO/ddu-source-source/blob/main/denops/%40ddu-sources/source.ts

Hm... ddu-source-source uses the feature.

[4513ECHO]

Remaining circular references:

1. types.ts and base.ui.ts
2. among ext.ts, ddu.ts and base/ui.ts

If we move the definition of UiActionArguments to types.ts, ① and ② is going to be resolved.
However, because of UiActionArguments depends on Ddu, a new circular reference between types.ts and ddu.ts is happening.

[4513ECHO]

This dependency was added at 3202e53. Why UiActionArguments requires Ddu?

[Shougo]

This dependency was added at 3202e53. Why UiActionArguments requires Ddu?

Because user actions want to use ddu like this.

    args.contextBuilder.patchGlobal({
      ui: "ff",
      profile: false,
      uiOptions: {
        ff: {
          actions: {
            kensaku: async (args: {
              denops: Denops;
              ddu: Ddu;
            }) => {
              args.ddu.updateOptions({
                sourceOptions: {
                  _: {
                    matchers: ["matcher_kensaku"],
                  },
                },
              });
              await args.denops.cmd("echomsg 'change to kensaku matcher'");

              return ActionFlags.Persist;
            },
          },
        },
        filer: {
          toggle: true,
        },
      },

Hm... It should use denops dispatcher instead.

[4513ECHO]

This pull request is now ready to use now.
@Shougo Could you release pre-release version to test?

Current dependencies graph:

[Shougo]

OK.