@oddessentials/agent-guild 0.1.0

package/node_modules/@xterm/xterm/src/common/services/LogService.ts

@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
+
+type LogType = (message?: any, ...optionalParams: any[]) => void;
+
+interface IConsole {
+  log: LogType;
+  error: LogType;
+  info: LogType;
+  trace: LogType;
+  warn: LogType;
+}
+
+// console is available on both node.js and browser contexts but the common
+// module doesn't depend on them so we need to explicitly declare it.
+declare const console: IConsole;
+
+const optionsKeyToLogLevel: { [key: string]: LogLevelEnum } = {
+  trace: LogLevelEnum.TRACE,
+  debug: LogLevelEnum.DEBUG,
+  info: LogLevelEnum.INFO,
+  warn: LogLevelEnum.WARN,
+  error: LogLevelEnum.ERROR,
+  off: LogLevelEnum.OFF
+};
+
+const LOG_PREFIX = 'xterm.js: ';
+
+export class LogService extends Disposable implements ILogService {
+  public serviceBrand: any;
+
+  private _logLevel: LogLevelEnum = LogLevelEnum.OFF;
+  public get logLevel(): LogLevelEnum { return this._logLevel; }
+
+  constructor(
+    @IOptionsService private readonly _optionsService: IOptionsService
+  ) {
+    super();
+    this._updateLogLevel();
+    this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
+
+    // For trace logging, assume the latest created log service is valid
+    traceLogger = this;
+  }
+
+  private _updateLogLevel(): void {
+    this._logLevel = optionsKeyToLogLevel[this._optionsService.rawOptions.logLevel];
+  }
+
+  private _evalLazyOptionalParams(optionalParams: any[]): void {
+    for (let i = 0; i < optionalParams.length; i++) {
+      if (typeof optionalParams[i] === 'function') {
+        optionalParams[i] = optionalParams[i]();
+      }
+    }
+  }
+
+  private _log(type: LogType, message: string, optionalParams: any[]): void {
+    this._evalLazyOptionalParams(optionalParams);
+    type.call(console, (this._optionsService.options.logger ? '' : LOG_PREFIX) + message, ...optionalParams);
+  }
+
+  public trace(message: string, ...optionalParams: any[]): void {
+    if (this._logLevel <= LogLevelEnum.TRACE) {
+      this._log(this._optionsService.options.logger?.trace.bind(this._optionsService.options.logger) ?? console.log, message, optionalParams);
+    }
+  }
+
+  public debug(message: string, ...optionalParams: any[]): void {
+    if (this._logLevel <= LogLevelEnum.DEBUG) {
+      this._log(this._optionsService.options.logger?.debug.bind(this._optionsService.options.logger) ?? console.log, message, optionalParams);
+    }
+  }
+
+  public info(message: string, ...optionalParams: any[]): void {
+    if (this._logLevel <= LogLevelEnum.INFO) {
+      this._log(this._optionsService.options.logger?.info.bind(this._optionsService.options.logger) ?? console.info, message, optionalParams);
+    }
+  }
+
+  public warn(message: string, ...optionalParams: any[]): void {
+    if (this._logLevel <= LogLevelEnum.WARN) {
+      this._log(this._optionsService.options.logger?.warn.bind(this._optionsService.options.logger) ?? console.warn, message, optionalParams);
+    }
+  }
+
+  public error(message: string, ...optionalParams: any[]): void {
+    if (this._logLevel <= LogLevelEnum.ERROR) {
+      this._log(this._optionsService.options.logger?.error.bind(this._optionsService.options.logger) ?? console.error, message, optionalParams);
+    }
+  }
+}
+
+let traceLogger: ILogService;
+export function setTraceLogger(logger: ILogService): void {
+  traceLogger = logger;
+}
+
+/**
+ * A decorator that can be used to automatically log trace calls to the decorated function.
+ */
+export function traceCall(_target: any, key: string, descriptor: any): any {
+  if (typeof descriptor.value !== 'function') {
+    throw new Error('not supported');
+  }
+  const fnKey = 'value';
+  const fn = descriptor.value;
+  descriptor[fnKey] = function (...args: any[]) {
+    // Early exit
+    if (traceLogger.logLevel !== LogLevelEnum.TRACE) {
+      return fn.apply(this, args);
+    }
+
+    traceLogger.trace(`GlyphRenderer#${fn.name}(${args.map(e => JSON.stringify(e)).join(', ')})`);
+    const result = fn.apply(this, args);
+    traceLogger.trace(`GlyphRenderer#${fn.name} return`, result);
+    return result;
+  };
+}

package/node_modules/@xterm/xterm/src/common/services/OptionsService.ts

@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { isMac } from 'common/Platform';
+import { CursorStyle, IDisposable } from 'common/Types';
+import { FontWeight, IOptionsService, ITerminalOptions } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
+
+export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
+  cols: 80,
+  rows: 24,
+  cursorBlink: false,
+  cursorStyle: 'block',
+  cursorWidth: 1,
+  cursorInactiveStyle: 'outline',
+  customGlyphs: true,
+  drawBoldTextInBrightColors: true,
+  documentOverride: null,
+  fastScrollModifier: 'alt',
+  fastScrollSensitivity: 5,
+  fontFamily: 'monospace',
+  fontSize: 15,
+  fontWeight: 'normal',
+  fontWeightBold: 'bold',
+  ignoreBracketedPasteMode: false,
+  lineHeight: 1.0,
+  letterSpacing: 0,
+  linkHandler: null,
+  logLevel: 'info',
+  logger: null,
+  scrollback: 1000,
+  scrollOnEraseInDisplay: false,
+  scrollOnUserInput: true,
+  scrollSensitivity: 1,
+  screenReaderMode: false,
+  smoothScrollDuration: 0,
+  macOptionIsMeta: false,
+  macOptionClickForcesSelection: false,
+  minimumContrastRatio: 1,
+  disableStdin: false,
+  allowProposedApi: false,
+  allowTransparency: false,
+  tabStopWidth: 8,
+  theme: {},
+  reflowCursorLine: false,
+  rescaleOverlappingGlyphs: false,
+  rightClickSelectsWord: isMac,
+  windowOptions: {},
+  windowsMode: false,
+  windowsPty: {},
+  wordSeparator: ' ()[]{}\',"`',
+  altClickMovesCursor: true,
+  convertEol: false,
+  termName: 'xterm',
+  cancelEvents: false,
+  overviewRuler: {}
+};
+
+const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
+
+export class OptionsService extends Disposable implements IOptionsService {
+  public serviceBrand: any;
+
+  public readonly rawOptions: Required<ITerminalOptions>;
+  public options: Required<ITerminalOptions>;
+
+  private readonly _onOptionChange = this._register(new Emitter<keyof ITerminalOptions>());
+  public readonly onOptionChange = this._onOptionChange.event;
+
+  constructor(options: Partial<ITerminalOptions>) {
+    super();
+    // set the default value of each option
+    const defaultOptions = { ...DEFAULT_OPTIONS };
+    for (const key in options) {
+      if (key in defaultOptions) {
+        try {
+          const newValue = options[key];
+          defaultOptions[key] = this._sanitizeAndValidateOption(key, newValue);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+
+    // set up getters and setters for each option
+    this.rawOptions = defaultOptions;
+    this.options = { ... defaultOptions };
+    this._setupOptions();
+
+    // Clear out options that could link outside xterm.js as they could easily cause an embedder
+    // memory leak
+    this._register(toDisposable(() => {
+      this.rawOptions.linkHandler = null;
+      this.rawOptions.documentOverride = null;
+    }));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  public onSpecificOptionChange<T extends keyof ITerminalOptions>(key: T, listener: (value: ITerminalOptions[T]) => any): IDisposable {
+    return this.onOptionChange(eventKey => {
+      if (eventKey === key) {
+        listener(this.rawOptions[key]);
+      }
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  public onMultipleOptionChange(keys: (keyof ITerminalOptions)[], listener: () => any): IDisposable {
+    return this.onOptionChange(eventKey => {
+      if (keys.indexOf(eventKey) !== -1) {
+        listener();
+      }
+    });
+  }
+
+  private _setupOptions(): void {
+    const getter = (propName: string): any => {
+      if (!(propName in DEFAULT_OPTIONS)) {
+        throw new Error(`No option with key "${propName}"`);
+      }
+      return this.rawOptions[propName];
+    };
+
+    const setter = (propName: string, value: any): void => {
+      if (!(propName in DEFAULT_OPTIONS)) {
+        throw new Error(`No option with key "${propName}"`);
+      }
+
+      value = this._sanitizeAndValidateOption(propName, value);
+      // Don't fire an option change event if they didn't change
+      if (this.rawOptions[propName] !== value) {
+        this.rawOptions[propName] = value;
+        this._onOptionChange.fire(propName);
+      }
+    };
+
+    for (const propName in this.rawOptions) {
+      const desc = {
+        get: getter.bind(this, propName),
+        set: setter.bind(this, propName)
+      };
+      Object.defineProperty(this.options, propName, desc);
+    }
+  }
+
+  private _sanitizeAndValidateOption(key: string, value: any): any {
+    switch (key) {
+      case 'cursorStyle':
+        if (!value) {
+          value = DEFAULT_OPTIONS[key];
+        }
+        if (!isCursorStyle(value)) {
+          throw new Error(`"${value}" is not a valid value for ${key}`);
+        }
+        break;
+      case 'wordSeparator':
+        if (!value) {
+          value = DEFAULT_OPTIONS[key];
+        }
+        break;
+      case 'fontWeight':
+      case 'fontWeightBold':
+        if (typeof value === 'number' && 1 <= value && value <= 1000) {
+          // already valid numeric value
+          break;
+        }
+        value = FONT_WEIGHT_OPTIONS.includes(value) ? value : DEFAULT_OPTIONS[key];
+        break;
+      case 'cursorWidth':
+        value = Math.floor(value);
+        // Fall through for bounds check
+      case 'lineHeight':
+      case 'tabStopWidth':
+        if (value < 1) {
+          throw new Error(`${key} cannot be less than 1, value: ${value}`);
+        }
+        break;
+      case 'minimumContrastRatio':
+        value = Math.max(1, Math.min(21, Math.round(value * 10) / 10));
+        break;
+      case 'scrollback':
+        value = Math.min(value, 4294967295);
+        if (value < 0) {
+          throw new Error(`${key} cannot be less than 0, value: ${value}`);
+        }
+        break;
+      case 'fastScrollSensitivity':
+      case 'scrollSensitivity':
+        if (value <= 0) {
+          throw new Error(`${key} cannot be less than or equal to 0, value: ${value}`);
+        }
+        break;
+      case 'rows':
+      case 'cols':
+        if (!value && value !== 0) {
+          throw new Error(`${key} must be numeric, value: ${value}`);
+        }
+        break;
+      case 'windowsPty':
+        value = value ?? {};
+        break;
+    }
+    return value;
+  }
+}
+
+function isCursorStyle(value: unknown): value is CursorStyle {
+  return value === 'block' || value === 'underline' || value === 'bar';
+}

package/node_modules/@xterm/xterm/src/common/services/OscLinkService.ts

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2022 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import { IBufferService, IOscLinkService } from 'common/services/Services';
+import { IMarker, IOscLinkData } from 'common/Types';
+
+export class OscLinkService implements IOscLinkService {
+  public serviceBrand: any;
+
+  private _nextId = 1;
+
+  /**
+   * A map of the link key to link entry. This is used to add additional lines to links with ids.
+   */
+  private _entriesWithId: Map<string, IOscLinkEntryWithId> = new Map();
+
+  /**
+   * A map of the link id to the link entry. The "link id" (number) which is the numberic
+   * representation of a unique link should not be confused with "id" (string) which comes in with
+   * `id=` in the OSC link's properties.
+   */
+  private _dataByLinkId: Map<number, IOscLinkEntryNoId | IOscLinkEntryWithId> = new Map();
+
+  constructor(
+    @IBufferService private readonly _bufferService: IBufferService
+  ) {
+  }
+
+  public registerLink(data: IOscLinkData): number {
+    const buffer = this._bufferService.buffer;
+
+    // Links with no id will only ever be registered a single time
+    if (data.id === undefined) {
+      const marker = buffer.addMarker(buffer.ybase + buffer.y);
+      const entry: IOscLinkEntryNoId = {
+        data,
+        id: this._nextId++,
+        lines: [marker]
+      };
+      marker.onDispose(() => this._removeMarkerFromLink(entry, marker));
+      this._dataByLinkId.set(entry.id, entry);
+      return entry.id;
+    }
+
+    // Add the line to the link if it already exists
+    const castData = data as Required<IOscLinkData>;
+    const key = this._getEntryIdKey(castData);
+    const match = this._entriesWithId.get(key);
+    if (match) {
+      this.addLineToLink(match.id, buffer.ybase + buffer.y);
+      return match.id;
+    }
+
+    // Create the link
+    const marker = buffer.addMarker(buffer.ybase + buffer.y);
+    const entry: IOscLinkEntryWithId = {
+      id: this._nextId++,
+      key: this._getEntryIdKey(castData),
+      data: castData,
+      lines: [marker]
+    };
+    marker.onDispose(() => this._removeMarkerFromLink(entry, marker));
+    this._entriesWithId.set(entry.key, entry);
+    this._dataByLinkId.set(entry.id, entry);
+    return entry.id;
+  }
+
+  public addLineToLink(linkId: number, y: number): void {
+    const entry = this._dataByLinkId.get(linkId);
+    if (!entry) {
+      return;
+    }
+    if (entry.lines.every(e => e.line !== y)) {
+      const marker = this._bufferService.buffer.addMarker(y);
+      entry.lines.push(marker);
+      marker.onDispose(() => this._removeMarkerFromLink(entry, marker));
+    }
+  }
+
+  public getLinkData(linkId: number): IOscLinkData | undefined {
+    return this._dataByLinkId.get(linkId)?.data;
+  }
+
+  private _getEntryIdKey(linkData: Required<IOscLinkData>): string {
+    return `${linkData.id};;${linkData.uri}`;
+  }
+
+  private _removeMarkerFromLink(entry: IOscLinkEntryNoId | IOscLinkEntryWithId, marker: IMarker): void {
+    const index = entry.lines.indexOf(marker);
+    if (index === -1) {
+      return;
+    }
+    entry.lines.splice(index, 1);
+    if (entry.lines.length === 0) {
+      if (entry.data.id !== undefined) {
+        this._entriesWithId.delete((entry as IOscLinkEntryWithId).key);
+      }
+      this._dataByLinkId.delete(entry.id);
+    }
+  }
+}
+
+interface IOscLinkEntry<T extends IOscLinkData> {
+  data: T;
+  id: number;
+  lines: IMarker[];
+}
+
+interface IOscLinkEntryNoId extends IOscLinkEntry<IOscLinkData> {
+}
+
+interface IOscLinkEntryWithId extends IOscLinkEntry<Required<IOscLinkData>> {
+  key: string;
+}

package/node_modules/@xterm/xterm/src/common/services/ServiceRegistry.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This was heavily inspired from microsoft/vscode's dependency injection system (MIT).
+ */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IServiceIdentifier } from 'common/services/Services';
+
+const DI_TARGET = 'di$target';
+const DI_DEPENDENCIES = 'di$dependencies';
+
+export const serviceRegistry: Map<string, IServiceIdentifier<any>> = new Map();
+
+export function getServiceDependencies(ctor: any): { id: IServiceIdentifier<any>, index: number, optional: boolean }[] {
+  return ctor[DI_DEPENDENCIES] || [];
+}
+
+export function createDecorator<T>(id: string): IServiceIdentifier<T> {
+  if (serviceRegistry.has(id)) {
+    return serviceRegistry.get(id)!;
+  }
+
+  const decorator: any = function (target: Function, key: string, index: number): any {
+    if (arguments.length !== 3) {
+      throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+    }
+
+    storeServiceDependency(decorator, target, index);
+  };
+
+  decorator._id = id;
+
+  serviceRegistry.set(id, decorator);
+  return decorator;
+}
+
+function storeServiceDependency(id: Function, target: Function, index: number): void {
+  if ((target as any)[DI_TARGET] === target) {
+    (target as any)[DI_DEPENDENCIES].push({ id, index });
+  } else {
+    (target as any)[DI_DEPENDENCIES] = [{ id, index }];
+    (target as any)[DI_TARGET] = target;
+  }
+}