@difizen/libro-common 0.3.4 → 1.0.0

package/src/core/context/data-context-manager.ts

@@ -0,0 +1,65 @@
+import type { Contribution, Syringe } from '../../ioc/index.js';
+import { contrib, inject, singleton } from '../../ioc/index.js';
+
+import { ManaContext } from '../module';
+
+import type { DataContextContriburtionKey } from './data-context-protocol';
+import { DataContextContriburtion, DataContextSymbol } from './data-context-protocol';
+
+@singleton()
+export class DataContextManager {
+  protected contributionMap?: Map<
+    DataContextContriburtionKey,
+    DataContextContriburtion
+  >;
+  protected contruibutions: DataContextContriburtion[] = [];
+  protected contextMap: Map<any, ManaContext> = new Map();
+  protected readonly provider: Contribution.Provider<DataContextContriburtion>;
+  protected readonly context: Syringe.Context;
+
+  constructor(
+    @contrib(DataContextContriburtion)
+    provider: Contribution.Provider<DataContextContriburtion>,
+    @inject(DataContextSymbol) context: Syringe.Context,
+  ) {
+    this.provider = provider;
+    this.context = context;
+  }
+
+  getContributionMap(): Map<DataContextContriburtionKey, DataContextContriburtion> {
+    if (this.contributionMap) {
+      return this.contributionMap;
+    }
+    this.contributionMap = new Map();
+    for (const contribution of this.provider.getContributions()) {
+      this.contributionMap.set(contribution.key, contribution);
+      this.contruibutions.push(contribution);
+    }
+    return this.contributionMap;
+  }
+
+  create(contributionKey: DataContextContriburtionKey, options?: any): any {
+    const contribution = this.getContributionMap().get(contributionKey);
+    if (contribution) {
+      const child = this.context.container.createChild();
+      const ctx = new ManaContext(child);
+      child.register({ token: DataContextSymbol, useDynamic: () => ctx });
+      child.load(contribution.module);
+      if (contribution.onCreate) {
+        contribution.onCreate(ctx, options);
+      }
+      let key: any;
+      if (contribution.getKey) {
+        key = contribution.getKey(ctx, options);
+      } else {
+        key = ctx;
+      }
+      this.contextMap.set(key, ctx);
+      return key;
+    }
+  }
+
+  getContext(key: any) {
+    return this.contextMap.get(key);
+  }
+}

package/src/core/context/data-context-protocol.ts

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Syringe } from '../../ioc/index.js';
+
+import type { ManaModule } from '../module';
+
+export type DataContextContriburtionKey = string | symbol;
+export const DataContextContriburtion = Syringe.defineToken('DataContextContriburtion');
+export interface DataContextContriburtion<T = any> {
+  key: DataContextContriburtionKey;
+  module: ManaModule;
+  onCreate?: (ctx: Syringe.Context, options?: T) => void;
+  getKey?: (ctx: Syringe.Context, options?: T) => any;
+}
+
+export const createDataContextContriburtion = (
+  contribution: DataContextContriburtion,
+) => {
+  return { token: DataContextContriburtion, useValue: contribution };
+};
+
+export const DataContextSymbol = Symbol('DataContextSymbol');

package/src/core/context/data-context.tsx

@@ -0,0 +1,40 @@
+import { getOrigin, ObservableContext, useInject } from '../../observable/index.js';
+import * as React from 'react';
+
+import type { ManaContext } from '../module';
+
+import { DataContextManager } from './data-context-manager';
+
+export interface DataContextProps {
+  contextKey: any;
+  children: React.ReactNode | React.ReactNode[];
+}
+
+interface DataContextRenderProps {
+  context?: ManaContext | undefined;
+  children: React.ReactNode | React.ReactNode[];
+}
+
+const DataContextRender = React.memo(
+  function DataContextRender(props: DataContextRenderProps) {
+    const { context, children } = props;
+    if (context) {
+      return (
+        <ObservableContext.Provider value={{ getContainer: () => context.container }}>
+          {children}
+        </ObservableContext.Provider>
+      );
+    }
+    return <></>;
+  },
+  (prev, next) => {
+    return prev.context === next.context;
+  },
+);
+
+export const DataContext = (props: DataContextProps) => {
+  const { contextKey, children } = props;
+  const dataContextManager = useInject<DataContextManager>(DataContextManager);
+  const ctx = dataContextManager.getContext(getOrigin(contextKey));
+  return <DataContextRender context={ctx}>{children}</DataContextRender>;
+};

package/src/core/context/index.ts

@@ -0,0 +1,15 @@
+import { ManaModule } from '../module';
+
+import { DataContextManager } from './data-context-manager';
+import { DataContextContriburtion, DataContextSymbol } from './data-context-protocol';
+
+export * from './data-context';
+export * from './data-context-manager';
+export * from './data-context-protocol';
+
+export const ContextModule = ManaModule.create()
+  .contribution(DataContextContriburtion)
+  .register(DataContextManager, {
+    token: DataContextSymbol,
+    useDynamic: (ctx) => ctx,
+  });

package/src/core/index.spec.ts

@@ -0,0 +1,14 @@
+import 'react';
+import assert from 'assert';
+
+import { ManaPreset, ManaComponents, ThemeModule } from './index';
+
+describe('app', () => {
+  it('#app import', () => {
+    assert(ManaPreset);
+    assert(ManaComponents);
+    assert(ManaComponents.Application);
+    assert(ManaComponents.Context);
+    assert(ThemeModule);
+  });
+});

package/src/core/index.ts

@@ -0,0 +1,57 @@
+import { ApplicationModule } from './application';
+import { CommandModule } from './command';
+import { CommonModule } from './common';
+import { ConfigurationModule } from './configuration';
+import { ContextModule } from './context';
+import { KeybindModule } from './keybinding';
+import { CoreMenuModule } from './menu';
+import { ManaModule } from './module';
+import { SelectionModule } from './selection';
+import { ThemeVariableModule } from './theme';
+import { CoreToolbarModule } from './toolbar';
+import { ViewModule } from './view';
+
+export * from './components';
+export * from './application';
+export * from './browser';
+export * from './command';
+export * from './menu';
+export * from './common';
+export * from './context';
+export * from './module';
+export * from './view';
+export * from './selection';
+export * from './theme';
+export * from './toolbar';
+export * from './keybinding';
+export * from './keyboard';
+export * from './configuration';
+export * from './utils';
+
+export const ManaPreset = ManaModule.create().dependOn(
+  CommonModule,
+  ApplicationModule,
+  ContextModule,
+  CommandModule,
+  CoreMenuModule,
+  CoreToolbarModule,
+  SelectionModule,
+  ThemeVariableModule,
+  ViewModule,
+  KeybindModule,
+  ConfigurationModule,
+);
+
+export const ManaModules = {
+  Common: CommonModule,
+  Application: ApplicationModule,
+  Command: CommandModule,
+  Menu: CoreMenuModule,
+  View: ViewModule,
+  Selection: SelectionModule,
+  Toolbar: CoreToolbarModule,
+  ThemeVariable: ThemeVariableModule,
+  Context: ContextModule,
+  Keybind: KeybindModule,
+  Configuration: ConfigurationModule,
+};

package/src/core/keybinding/context-key-service.ts

@@ -0,0 +1,77 @@
+import { Emitter } from '../../common/index.js';
+import { inject, postConstruct, singleton } from '../../ioc/index.js';
+
+import type { ContextKeyExpression, IContextKey } from './vs/contextkey';
+import { ContextKeyExpr } from './vs/contextkey';
+import { VSContextKeyService } from './vs/contextKeyService';
+
+export type ContextKeyChangeEvent = {
+  affects: (keys: Set<string>) => boolean;
+};
+
+@singleton()
+export class ContextKeyService {
+  protected readonly onDidChangeEmitter = new Emitter<ContextKeyChangeEvent>();
+  readonly onDidChange = this.onDidChangeEmitter.event;
+  protected fireDidChange(event: ContextKeyChangeEvent): void {
+    this.onDidChangeEmitter.fire(event);
+  }
+
+  protected readonly contextKeyService: VSContextKeyService;
+  protected readonly vsContextKeyService: VSContextKeyService;
+
+  constructor(@inject(VSContextKeyService) vsContextKeyService: VSContextKeyService) {
+    this.vsContextKeyService = vsContextKeyService;
+    this.contextKeyService = vsContextKeyService;
+  }
+
+  @postConstruct()
+  protected init(): void {
+    this.contextKeyService.onDidChangeContext((e) =>
+      this.fireDidChange({
+        affects: (keys) => e.affectsSome(keys),
+      }),
+    );
+  }
+
+  createKey<T>(key: string, defaultValue: T | undefined): IContextKey<T> {
+    return this.contextKeyService.createKey(key, defaultValue);
+  }
+
+  activeContext?: HTMLElement;
+
+  match(expression: string, context?: HTMLElement): boolean {
+    const ctx =
+      context ||
+      this.activeContext ||
+      (window.document.activeElement instanceof HTMLElement
+        ? window.document.activeElement
+        : undefined);
+    const parsed = this.parse(expression);
+    if (!ctx) {
+      return this.contextKeyService.contextMatchesRules(parsed);
+    }
+    const keyContext = this.contextKeyService.getContext(ctx);
+    if (!parsed) {
+      return true;
+    }
+    return parsed.evaluate(keyContext);
+  }
+
+  protected readonly expressions = new Map<string, ContextKeyExpression>();
+  protected parse(when: string): ContextKeyExpression | undefined {
+    let expression = this.expressions.get(when);
+    if (!expression) {
+      expression = ContextKeyExpr.deserialize(when);
+      if (expression) {
+        this.expressions.set(when, expression);
+      }
+    }
+    return expression;
+  }
+
+  parseKeys(expression: string): Set<string> | undefined {
+    const expr = ContextKeyExpr.deserialize(expression);
+    return expr ? new Set<string>(expr.keys()) : expr;
+  }
+}

package/src/core/keybinding/index.ts

@@ -0,0 +1,5 @@
+export { KeybindingContribution } from './keybinding-proocol';
+export { KeybindingRegistry } from './keybinding';
+export { ContextKeyService } from './context-key-service';
+export * from './vs/contextkey';
+export * from './module';

package/src/core/keybinding/keybinding-proocol.ts

@@ -0,0 +1,15 @@
+import { Syringe } from '../../ioc/index.js';
+
+import type { KeybindingRegistry } from './keybinding';
+
+export const KeybindingContribution = Syringe.defineToken('KeybindingContribution');
+/**
+ * Allows extensions to contribute {@link common.Keybinding}s
+ */
+export type KeybindingContribution = {
+  /**
+   * Registers keybindings.
+   * @param keybindings the keybinding registry.
+   */
+  registerKeybindings: (keybindings: KeybindingRegistry) => void;
+};