@difizen/libro-common 0.3.4 → 1.0.0

package/es/core/configuration/validation.js

@@ -0,0 +1,45 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _class;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { getOrigin } from "../../observable/index.js";
+import { singleton } from "../../ioc/index.js";
+import Ajv from 'ajv';
+export var SchemaValidator = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function SchemaValidator() {
+    _classCallCheck(this, SchemaValidator);
+    this.ajvInstance = new Ajv();
+  }
+  _createClass(SchemaValidator, [{
+    key: "addSchema",
+    value:
+    /**
+     * https://ajv.js.org/guide/managing-schemas.html#using-ajv-instance-cache
+     */
+    function addSchema(node) {
+      getOrigin(this.ajvInstance).addSchema(node.schema, node.id);
+    }
+  }, {
+    key: "getSchema",
+    value: function getSchema(node) {
+      return getOrigin(this.ajvInstance).getSchema(node.id);
+    }
+  }, {
+    key: "validateNode",
+    value: function validateNode(node, value) {
+      var validate = this.getSchema(node);
+      if (validate === undefined) {
+        return false;
+      }
+      var valid = validate(value);
+      if (!valid) {
+        console.warn(validate.errors);
+      }
+      return valid;
+    }
+  }]);
+  return SchemaValidator;
+}()) || _class);

package/es/core/context/data-context-manager.d.ts

@@ -0,0 +1,16 @@
+import type { Contribution, Syringe } from '../../ioc/index.js';
+import { ManaContext } from '../module';
+import type { DataContextContriburtionKey } from './data-context-protocol';
+import { DataContextContriburtion } from './data-context-protocol';
+export declare class DataContextManager {
+    protected contributionMap?: Map<DataContextContriburtionKey, DataContextContriburtion>;
+    protected contruibutions: DataContextContriburtion[];
+    protected contextMap: Map<any, ManaContext>;
+    protected readonly provider: Contribution.Provider<DataContextContriburtion>;
+    protected readonly context: Syringe.Context;
+    constructor(provider: Contribution.Provider<DataContextContriburtion>, context: Syringe.Context);
+    getContributionMap(): Map<DataContextContriburtionKey, DataContextContriburtion>;
+    create(contributionKey: DataContextContriburtionKey, options?: any): any;
+    getContext(key: any): ManaContext | undefined;
+}
+//# sourceMappingURL=data-context-manager.d.ts.map

package/es/core/context/data-context-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-context-manager.d.ts","sourceRoot":"","sources":["../../../src/core/context/data-context-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAqB,MAAM,yBAAyB,CAAC;AAEtF,qBACa,kBAAkB;IAC7B,SAAS,CAAC,eAAe,CAAC,EAAE,GAAG,CAC7B,2BAA2B,EAC3B,wBAAwB,CACzB,CAAC;IACF,SAAS,CAAC,cAAc,EAAE,wBAAwB,EAAE,CAAM;IAC1D,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAa;IACxD,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;IAC7E,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAI1C,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAC9B,OAAO,EAAE,OAAO,CAAC,OAAO;IAMrD,kBAAkB,IAAI,GAAG,CAAC,2BAA2B,EAAE,wBAAwB,CAAC;IAYhF,MAAM,CAAC,eAAe,EAAE,2BAA2B,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,GAAG;IAqBxE,UAAU,CAAC,GAAG,EAAE,GAAG;CAGpB"}

package/es/core/context/data-context-manager.js

@@ -0,0 +1,80 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _class;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { contrib, inject, singleton } from "../../ioc/index.js";
+import { ManaContext } from "../module";
+import { DataContextContriburtion, DataContextSymbol } from "./data-context-protocol";
+export var DataContextManager = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function DataContextManager(provider, context) {
+    _classCallCheck(this, DataContextManager);
+    this.contruibutions = [];
+    this.contextMap = new Map();
+    this.provider = provider;
+    this.context = context;
+  }
+  DataContextManager = inject(DataContextSymbol)(DataContextManager, undefined, 1) || DataContextManager;
+  DataContextManager = contrib(DataContextContriburtion)(DataContextManager, undefined, 0) || DataContextManager;
+  _createClass(DataContextManager, [{
+    key: "getContributionMap",
+    value: function getContributionMap() {
+      if (this.contributionMap) {
+        return this.contributionMap;
+      }
+      this.contributionMap = new Map();
+      var _iterator = _createForOfIteratorHelper(this.provider.getContributions()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var contribution = _step.value;
+          this.contributionMap.set(contribution.key, contribution);
+          this.contruibutions.push(contribution);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return this.contributionMap;
+    }
+  }, {
+    key: "create",
+    value: function create(contributionKey, options) {
+      var contribution = this.getContributionMap().get(contributionKey);
+      if (contribution) {
+        var child = this.context.container.createChild();
+        var ctx = new ManaContext(child);
+        child.register({
+          token: DataContextSymbol,
+          useDynamic: function useDynamic() {
+            return ctx;
+          }
+        });
+        child.load(contribution.module);
+        if (contribution.onCreate) {
+          contribution.onCreate(ctx, options);
+        }
+        var key;
+        if (contribution.getKey) {
+          key = contribution.getKey(ctx, options);
+        } else {
+          key = ctx;
+        }
+        this.contextMap.set(key, ctx);
+        return key;
+      }
+    }
+  }, {
+    key: "getContext",
+    value: function getContext(key) {
+      return this.contextMap.get(key);
+    }
+  }]);
+  return DataContextManager;
+}()) || _class);

package/es/core/context/data-context-protocol.d.ts

@@ -0,0 +1,16 @@
+import { Syringe } from '../../ioc/index.js';
+import type { ManaModule } from '../module';
+export type DataContextContriburtionKey = string | symbol;
+export declare const DataContextContriburtion: Syringe.DefinedToken;
+export interface DataContextContriburtion<T = any> {
+    key: DataContextContriburtionKey;
+    module: ManaModule;
+    onCreate?: (ctx: Syringe.Context, options?: T) => void;
+    getKey?: (ctx: Syringe.Context, options?: T) => any;
+}
+export declare const createDataContextContriburtion: (contribution: DataContextContriburtion) => {
+    token: Syringe.DefinedToken;
+    useValue: DataContextContriburtion<any>;
+};
+export declare const DataContextSymbol: unique symbol;
+//# sourceMappingURL=data-context-protocol.d.ts.map

package/es/core/context/data-context-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-context-protocol.d.ts","sourceRoot":"","sources":["../../../src/core/context/data-context-protocol.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG,MAAM,CAAC;AAC1D,eAAO,MAAM,wBAAwB,sBAAkD,CAAC;AACxF,MAAM,WAAW,wBAAwB,CAAC,CAAC,GAAG,GAAG;IAC/C,GAAG,EAAE,2BAA2B,CAAC;IACjC,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACvD,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC;CACrD;AAED,eAAO,MAAM,8BAA8B,iBAC3B,wBAAwB;;;CAGvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,eAA8B,CAAC"}

package/es/core/context/data-context-protocol.js

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Syringe } from "../../ioc/index.js";
+export var DataContextContriburtion = Syringe.defineToken('DataContextContriburtion');
+export var createDataContextContriburtion = function createDataContextContriburtion(contribution) {
+  return {
+    token: DataContextContriburtion,
+    useValue: contribution
+  };
+};
+export var DataContextSymbol = Symbol('DataContextSymbol');

package/es/core/context/data-context.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface DataContextProps {
+    contextKey: any;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare const DataContext: (props: DataContextProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=data-context.d.ts.map

package/es/core/context/data-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-context.d.ts","sourceRoot":"","sources":["../../../src/core/context/data-context.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,GAAG,CAAC;IAChB,QAAQ,EAAE,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;CAC/C;AAwBD,eAAO,MAAM,WAAW,UAAW,gBAAgB,4CAKlD,CAAC"}

package/es/core/context/data-context.js

@@ -0,0 +1,32 @@
+import { getOrigin, ObservableContext, useInject } from "../../observable/index.js";
+import * as React from 'react';
+import { DataContextManager } from "./data-context-manager";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+var DataContextRender = /*#__PURE__*/React.memo(function DataContextRender(props) {
+  var context = props.context,
+    children = props.children;
+  if (context) {
+    return /*#__PURE__*/_jsx(ObservableContext.Provider, {
+      value: {
+        getContainer: function getContainer() {
+          return context.container;
+        }
+      },
+      children: children
+    });
+  }
+  return /*#__PURE__*/_jsx(_Fragment, {});
+}, function (prev, next) {
+  return prev.context === next.context;
+});
+export var DataContext = function DataContext(props) {
+  var contextKey = props.contextKey,
+    children = props.children;
+  var dataContextManager = useInject(DataContextManager);
+  var ctx = dataContextManager.getContext(getOrigin(contextKey));
+  return /*#__PURE__*/_jsx(DataContextRender, {
+    context: ctx,
+    children: children
+  });
+};

package/es/core/context/index.d.ts

@@ -0,0 +1,6 @@
+import { ManaModule } from '../module';
+export * from './data-context';
+export * from './data-context-manager';
+export * from './data-context-protocol';
+export declare const ContextModule: ManaModule;
+//# sourceMappingURL=index.d.ts.map

package/es/core/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/context/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAKvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AAExC,eAAO,MAAM,aAAa,YAKtB,CAAC"}

package/es/core/context/index.js

@@ -0,0 +1,12 @@
+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 var ContextModule = ManaModule.create().contribution(DataContextContriburtion).register(DataContextManager, {
+  token: DataContextSymbol,
+  useDynamic: function useDynamic(ctx) {
+    return ctx;
+  }
+});

package/es/core/index.d.ts

@@ -0,0 +1,32 @@
+import { ManaModule } from './module';
+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 declare const ManaPreset: ManaModule;
+export declare const ManaModules: {
+    Common: ManaModule;
+    Application: ManaModule;
+    Command: ManaModule;
+    Menu: ManaModule;
+    View: ManaModule;
+    Selection: ManaModule;
+    Toolbar: ManaModule;
+    ThemeVariable: ManaModule;
+    Context: ManaModule;
+    Keybind: ManaModule;
+    Configuration: ManaModule;
+};
+//# sourceMappingURL=index.d.ts.map

package/es/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAMtC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AAExB,eAAO,MAAM,UAAU,YAYtB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;CAYvB,CAAC"}

package/es/core/index.js

@@ -0,0 +1,42 @@
+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 var ManaPreset = ManaModule.create().dependOn(CommonModule, ApplicationModule, ContextModule, CommandModule, CoreMenuModule, CoreToolbarModule, SelectionModule, ThemeVariableModule, ViewModule, KeybindModule, ConfigurationModule);
+export var ManaModules = {
+  Common: CommonModule,
+  Application: ApplicationModule,
+  Command: CommandModule,
+  Menu: CoreMenuModule,
+  View: ViewModule,
+  Selection: SelectionModule,
+  Toolbar: CoreToolbarModule,
+  ThemeVariable: ThemeVariableModule,
+  Context: ContextModule,
+  Keybind: KeybindModule,
+  Configuration: ConfigurationModule
+};

package/es/core/keybinding/context-key-service.d.ts

@@ -0,0 +1,22 @@
+import { Emitter } from '../../common/index.js';
+import type { ContextKeyExpression, IContextKey } from './vs/contextkey';
+import { VSContextKeyService } from './vs/contextKeyService';
+export type ContextKeyChangeEvent = {
+    affects: (keys: Set<string>) => boolean;
+};
+export declare class ContextKeyService {
+    protected readonly onDidChangeEmitter: Emitter<ContextKeyChangeEvent>;
+    readonly onDidChange: import("../../common/event.js").Event<ContextKeyChangeEvent>;
+    protected fireDidChange(event: ContextKeyChangeEvent): void;
+    protected readonly contextKeyService: VSContextKeyService;
+    protected readonly vsContextKeyService: VSContextKeyService;
+    constructor(vsContextKeyService: VSContextKeyService);
+    protected init(): void;
+    createKey<T>(key: string, defaultValue: T | undefined): IContextKey<T>;
+    activeContext?: HTMLElement;
+    match(expression: string, context?: HTMLElement): boolean;
+    protected readonly expressions: Map<string, ContextKeyExpression>;
+    protected parse(when: string): ContextKeyExpression | undefined;
+    parseKeys(expression: string): Set<string> | undefined;
+}
+//# sourceMappingURL=context-key-service.d.ts.map

package/es/core/keybinding/context-key-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-key-service.d.ts","sourceRoot":"","sources":["../../../src/core/keybinding/context-key-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC;CACzC,CAAC;AAEF,qBACa,iBAAiB;IAC5B,SAAS,CAAC,QAAQ,CAAC,kBAAkB,iCAAwC;IAC7E,QAAQ,CAAC,WAAW,+DAAiC;IACrD,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI;IAI3D,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;IAC1D,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;gBAEnB,mBAAmB,EAAE,mBAAmB;IAMjF,SAAS,CAAC,IAAI,IAAI,IAAI;IAQtB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC;IAItE,aAAa,CAAC,EAAE,WAAW,CAAC;IAE5B,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO;IAkBzD,SAAS,CAAC,QAAQ,CAAC,WAAW,oCAA2C;IACzE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAW/D,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS;CAIvD"}

package/es/core/keybinding/context-key-service.js

@@ -0,0 +1,79 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _dec2, _class, _class2;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+import { Emitter } from "../../common/index.js";
+import { inject, postConstruct, singleton } from "../../ioc/index.js";
+import { ContextKeyExpr } from "./vs/contextkey";
+import { VSContextKeyService } from "./vs/contextKeyService";
+export var ContextKeyService = (_dec = singleton(), _dec2 = postConstruct(), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function ContextKeyService(vsContextKeyService) {
+    _classCallCheck(this, ContextKeyService);
+    this.onDidChangeEmitter = new Emitter();
+    this.onDidChange = this.onDidChangeEmitter.event;
+    this.expressions = new Map();
+    this.vsContextKeyService = vsContextKeyService;
+    this.contextKeyService = vsContextKeyService;
+  }
+  ContextKeyService = inject(VSContextKeyService)(ContextKeyService, undefined, 0) || ContextKeyService;
+  _createClass(ContextKeyService, [{
+    key: "fireDidChange",
+    value: function fireDidChange(event) {
+      this.onDidChangeEmitter.fire(event);
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _this = this;
+      this.contextKeyService.onDidChangeContext(function (e) {
+        return _this.fireDidChange({
+          affects: function affects(keys) {
+            return e.affectsSome(keys);
+          }
+        });
+      });
+    }
+  }, {
+    key: "createKey",
+    value: function createKey(key, defaultValue) {
+      return this.contextKeyService.createKey(key, defaultValue);
+    }
+  }, {
+    key: "match",
+    value: function match(expression, context) {
+      var ctx = context || this.activeContext || (window.document.activeElement instanceof HTMLElement ? window.document.activeElement : undefined);
+      var parsed = this.parse(expression);
+      if (!ctx) {
+        return this.contextKeyService.contextMatchesRules(parsed);
+      }
+      var keyContext = this.contextKeyService.getContext(ctx);
+      if (!parsed) {
+        return true;
+      }
+      return parsed.evaluate(keyContext);
+    }
+  }, {
+    key: "parse",
+    value: function parse(when) {
+      var expression = this.expressions.get(when);
+      if (!expression) {
+        expression = ContextKeyExpr.deserialize(when);
+        if (expression) {
+          this.expressions.set(when, expression);
+        }
+      }
+      return expression;
+    }
+  }, {
+    key: "parseKeys",
+    value: function parseKeys(expression) {
+      var expr = ContextKeyExpr.deserialize(expression);
+      return expr ? new Set(expr.keys()) : expr;
+    }
+  }]);
+  return ContextKeyService;
+}(), (_applyDecoratedDescriptor(_class2.prototype, "init", [_dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "init"), _class2.prototype)), _class2)) || _class);

package/es/core/keybinding/index.d.ts

@@ -0,0 +1,6 @@
+export { KeybindingContribution } from './keybinding-proocol';
+export { KeybindingRegistry } from './keybinding';
+export { ContextKeyService } from './context-key-service';
+export * from './vs/contextkey';
+export * from './module';
+//# sourceMappingURL=index.d.ts.map

package/es/core/keybinding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/keybinding/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC"}

package/es/core/keybinding/index.js

@@ -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/es/core/keybinding/keybinding-proocol.d.ts

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

package/es/core/keybinding/keybinding-proocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keybinding-proocol.d.ts","sourceRoot":"","sources":["../../../src/core/keybinding/keybinding-proocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,eAAO,MAAM,sBAAsB,sBAAgD,CAAC;AACpF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;OAGG;IACH,mBAAmB,EAAE,CAAC,WAAW,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAChE,CAAC"}

package/es/core/keybinding/keybinding-proocol.js

@@ -0,0 +1,5 @@
+import { Syringe } from "../../ioc/index.js";
+export var KeybindingContribution = Syringe.defineToken('KeybindingContribution');
+/**
+ * Allows extensions to contribute {@link common.Keybinding}s
+ */