@workbench-kit/monaco 0.0.2-prototype.0.2.10

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@workbench-kit/monaco",
+  "version": "0.0.2-prototype.0.2.10",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./environment": "./src/installMonacoEnvironment.ts"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.stories.ts",
+    "!src/**/*.stories.tsx"
+  ],
+  "dependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "monaco-editor": "^0.56.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "description": "Monaco editor integration for Workbench Kit hosts and UI packages.",
+  "publishConfig": {
+    "access": "public",
+    "tag": "prototype",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NewChoBo/workbench-kit.git",
+    "directory": "packages/monaco"
+  },
+  "scripts": {
+    "test": "pnpm exec vitest run --config ../../vitest.config.ts src",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/WorkbenchMonacoEditor.tsx

@@ -0,0 +1,108 @@
+import { useCallback, type ReactNode } from 'react';
+import type { OnMount } from '@monaco-editor/react';
+import type * as Monaco from 'monaco-editor';
+
+import { Editor } from './monaco-loader.js';
+import type { WorkbenchMonaco } from './monaco-loader.js';
+import {
+  defineMonacoWorkbenchTheme,
+  monacoThemeForWorkspaceTheme,
+  type MonacoWorkbenchResolvedTheme,
+} from './monacoWorkbenchTheme.js';
+import { configureWorkspaceEditorTypeScriptDiagnostics } from './workspaceTypeScriptDiagnostics.js';
+
+export type WorkbenchMonacoEditorTheme = MonacoWorkbenchResolvedTheme;
+
+export function prepareMonacoWorkbenchEditor(
+  monacoInstance: WorkbenchMonaco,
+  resolvedTheme: WorkbenchMonacoEditorTheme = 'dark',
+) {
+  defineMonacoWorkbenchTheme(monacoInstance, resolvedTheme);
+  configureWorkspaceEditorTypeScriptDiagnostics(monacoInstance);
+}
+
+export interface WorkbenchMonacoEditorProps {
+  beforeMount?: ((monacoInstance: WorkbenchMonaco) => void) | undefined;
+  className?: string | undefined;
+  height?: number | string | undefined;
+  language: string;
+  loading?: ReactNode | undefined;
+  onChange?: ((value: string) => void) | undefined;
+  onMount?: OnMount | undefined;
+  options?: Monaco.editor.IStandaloneEditorConstructionOptions | undefined;
+  path?: string | undefined;
+  readOnly?: boolean | undefined;
+  theme?: WorkbenchMonacoEditorTheme | undefined;
+  value?: string | undefined;
+}
+
+const defaultEditorOptions: Monaco.editor.IStandaloneEditorConstructionOptions = {
+  automaticLayout: true,
+  contextmenu: true,
+  fixedOverflowWidgets: true,
+  fontFamily: 'ui-monospace, SFMono-Regular, Consolas, monospace',
+  fontSize: 13,
+  lineHeight: 20,
+  glyphMargin: false,
+  minimap: { enabled: false },
+  overviewRulerBorder: false,
+  overviewRulerLanes: 0,
+  padding: { bottom: 12, top: 12 },
+  renderLineHighlight: 'line',
+  scrollBeyondLastLine: false,
+  scrollbar: {
+    alwaysConsumeMouseWheel: false,
+    horizontalScrollbarSize: 10,
+    verticalScrollbarSize: 10,
+  },
+  tabSize: 2,
+  wordWrap: 'on',
+};
+
+export function WorkbenchMonacoEditor({
+  beforeMount,
+  className,
+  height = '100%',
+  language,
+  loading = (
+    <div className="ui-panel-loading ui-panel-centered-state" role="status" aria-live="polite">
+      <i aria-hidden className="codicon codicon-loading codicon-modifier-spin" />
+      <span>Loading editor...</span>
+    </div>
+  ),
+  onChange,
+  onMount,
+  options,
+  path,
+  readOnly = false,
+  theme = 'dark',
+  value = '',
+}: WorkbenchMonacoEditorProps) {
+  const handleBeforeMount = useCallback(
+    (monacoInstance: WorkbenchMonaco) => {
+      prepareMonacoWorkbenchEditor(monacoInstance, theme);
+      beforeMount?.(monacoInstance);
+    },
+    [beforeMount, theme],
+  );
+
+  return (
+    <Editor
+      className={className}
+      beforeMount={handleBeforeMount}
+      height={height}
+      language={language}
+      loading={loading}
+      options={{
+        ...defaultEditorOptions,
+        ...options,
+        readOnly,
+      }}
+      path={path}
+      theme={monacoThemeForWorkspaceTheme(theme)}
+      value={value}
+      onChange={(nextValue) => onChange?.(nextValue ?? '')}
+      onMount={onMount}
+    />
+  );
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export type { OnMount } from '@monaco-editor/react';
+export type { IDisposable, editor } from 'monaco-editor';
+export type { WorkbenchMonaco } from './monaco-loader.js';
+
+export { Editor, loader, monaco } from './monaco-loader.js';
+export {
+  createMonacoWorker,
+  installMonacoEnvironment,
+  resolveMonacoWorkerSource,
+  type InstallMonacoEnvironmentOptions,
+  type MonacoEnvironmentWorkers,
+  type MonacoWorkerSource,
+} from './installMonacoEnvironment.js';
+export {
+  MONACO_DARK_THEME_ID,
+  MONACO_LIGHT_THEME_ID,
+  buildMonacoThemeColors,
+  defineMonacoWorkbenchTheme,
+  getWorkbenchThemeAppearanceSignature,
+  monacoThemeForWorkspaceTheme,
+  readWorkbenchThemeColors,
+  resolveMonacoThemeRoot,
+  withAlpha,
+  type MonacoWorkbenchResolvedTheme,
+  type WorkbenchThemeCssColors,
+} from './monacoWorkbenchTheme.js';
+export { useMonacoWorkbenchThemeSync } from './useMonacoWorkbenchThemeSync.js';
+export { configureWorkspaceEditorTypeScriptDiagnostics } from './workspaceTypeScriptDiagnostics.js';
+export {
+  WorkbenchMonacoEditor,
+  prepareMonacoWorkbenchEditor,
+  type WorkbenchMonacoEditorProps,
+  type WorkbenchMonacoEditorTheme,
+} from './WorkbenchMonacoEditor.js';

package/src/installMonacoEnvironment.ts

@@ -0,0 +1,76 @@
+/**
+ * Bundler-agnostic `MonacoEnvironment.getWorker` bootstrap.
+ *
+ * Pass worker **URL strings** (Vite `?worker&url`) or **factories** that return
+ * a `Worker` (Vite/Storybook `?worker` constructors wrapped as `() => new Ctor()`).
+ */
+
+export type MonacoWorkerSource = string | (() => Worker);
+
+export interface MonacoEnvironmentWorkers {
+  readonly editor: MonacoWorkerSource;
+  readonly json?: MonacoWorkerSource | undefined;
+  readonly css?: MonacoWorkerSource | undefined;
+  readonly html?: MonacoWorkerSource | undefined;
+  readonly typescript?: MonacoWorkerSource | undefined;
+}
+
+export interface InstallMonacoEnvironmentOptions {
+  /** Worker `type` when the source is a URL string. Defaults to `module`. */
+  readonly workerType?: WorkerType | undefined;
+}
+
+type MonacoEnvironmentGlobal = typeof globalThis & {
+  MonacoEnvironment?: {
+    getWorker?: (moduleId: string, label: string) => Worker;
+  };
+};
+
+/** Resolve the worker source for a Monaco language label (unknown → editor). */
+export function resolveMonacoWorkerSource(
+  label: string,
+  workers: MonacoEnvironmentWorkers,
+): MonacoWorkerSource {
+  if (label === 'json') {
+    return workers.json ?? workers.editor;
+  }
+  if (label === 'css' || label === 'scss' || label === 'less') {
+    return workers.css ?? workers.editor;
+  }
+  if (label === 'html' || label === 'handlebars' || label === 'razor') {
+    return workers.html ?? workers.editor;
+  }
+  if (label === 'typescript' || label === 'javascript') {
+    return workers.typescript ?? workers.editor;
+  }
+  return workers.editor;
+}
+
+export function createMonacoWorker(
+  source: MonacoWorkerSource,
+  label: string,
+  workerType: WorkerType = 'module',
+): Worker {
+  if (typeof source === 'string') {
+    return new Worker(source, { name: `monaco-${label}-worker`, type: workerType });
+  }
+  return source();
+}
+
+/**
+ * Installs `globalThis.MonacoEnvironment.getWorker` from a label→source map.
+ * Safe to call more than once (replaces `getWorker`).
+ */
+export function installMonacoEnvironment(
+  workers: MonacoEnvironmentWorkers,
+  options: InstallMonacoEnvironmentOptions = {},
+): void {
+  const workerType = options.workerType ?? 'module';
+  const monacoGlobal = globalThis as MonacoEnvironmentGlobal;
+
+  monacoGlobal.MonacoEnvironment = {
+    ...monacoGlobal.MonacoEnvironment,
+    getWorker: (_moduleId: string, label: string) =>
+      createMonacoWorker(resolveMonacoWorkerSource(label, workers), label, workerType),
+  };
+}

package/src/monaco-loader.ts

@@ -0,0 +1,8 @@
+import Editor, { loader } from '@monaco-editor/react';
+import * as monaco from 'monaco-editor';
+
+loader.config({ monaco });
+
+export type WorkbenchMonaco = typeof monaco;
+
+export { Editor, loader, monaco };

package/src/monacoWorkbenchTheme.ts

@@ -0,0 +1,178 @@
+import type * as monaco from 'monaco-editor';
+
+export const MONACO_DARK_THEME_ID = 'workbench-kit-dark';
+export const MONACO_LIGHT_THEME_ID = 'workbench-kit-light';
+
+export type MonacoWorkbenchResolvedTheme = 'dark' | 'light';
+
+export interface WorkbenchThemeCssColors {
+  accent: string;
+  bg: string;
+  border: string;
+  danger: string;
+  focusBorder: string;
+  scrollbarThumb: string;
+  scrollbarThumbActive: string;
+  scrollbarThumbHover: string;
+  surface: string;
+  surfaceElevated: string;
+  surfaceHover: string;
+  text: string;
+  textMuted: string;
+  textSubtle: string;
+}
+
+function readCssVariable(root: HTMLElement, variableName: string): string {
+  return getComputedStyle(root).getPropertyValue(variableName).trim();
+}
+
+export function readWorkbenchThemeColors(root: HTMLElement): WorkbenchThemeCssColors {
+  return {
+    accent: readCssVariable(root, '--color-accent'),
+    bg: readCssVariable(root, '--color-bg'),
+    border: readCssVariable(root, '--color-border'),
+    danger: readCssVariable(root, '--color-danger'),
+    focusBorder: readCssVariable(root, '--color-focus-border'),
+    scrollbarThumb: readCssVariable(root, '--scrollbar-thumb'),
+    scrollbarThumbActive: readCssVariable(root, '--scrollbar-thumb-active'),
+    scrollbarThumbHover: readCssVariable(root, '--scrollbar-thumb-hover'),
+    surface: readCssVariable(root, '--color-surface'),
+    surfaceElevated: readCssVariable(root, '--color-surface-elevated'),
+    surfaceHover: readCssVariable(root, '--color-surface-hover'),
+    text: readCssVariable(root, '--color-text'),
+    textMuted: readCssVariable(root, '--color-text-muted'),
+    textSubtle: readCssVariable(root, '--color-text-subtle'),
+  };
+}
+
+function parseRgbChannels(color: string): [number, number, number] | null {
+  const normalized = color.trim();
+
+  const hexMatch = normalized.match(/^#([0-9a-f]{3,8})$/i);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    if (hex.length === 3) {
+      return [
+        Number.parseInt(hex[0] + hex[0], 16),
+        Number.parseInt(hex[1] + hex[1], 16),
+        Number.parseInt(hex[2] + hex[2], 16),
+      ];
+    }
+    if (hex.length === 6 || hex.length === 8) {
+      return [
+        Number.parseInt(hex.slice(0, 2), 16),
+        Number.parseInt(hex.slice(2, 4), 16),
+        Number.parseInt(hex.slice(4, 6), 16),
+      ];
+    }
+  }
+
+  const rgbMatch = normalized.match(
+    /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*[\d.]+\s*)?\)$/i,
+  );
+  if (rgbMatch) {
+    return [
+      Math.round(Number(rgbMatch[1])),
+      Math.round(Number(rgbMatch[2])),
+      Math.round(Number(rgbMatch[3])),
+    ];
+  }
+
+  return null;
+}
+
+export function withAlpha(color: string, alpha: number): string {
+  const channels = parseRgbChannels(color);
+  if (!channels) {
+    return color;
+  }
+
+  const clampedAlpha = Math.min(1, Math.max(0, alpha));
+  const alphaHex = Math.round(clampedAlpha * 255)
+    .toString(16)
+    .padStart(2, '0');
+  const [red, green, blue] = channels;
+  return `#${red.toString(16).padStart(2, '0')}${green.toString(16).padStart(2, '0')}${blue.toString(16).padStart(2, '0')}${alphaHex}`;
+}
+
+export function buildMonacoThemeColors(colors: WorkbenchThemeCssColors): monaco.editor.IColors {
+  return {
+    'editor.background': colors.bg,
+    'editor.foreground': colors.text,
+    'editorGutter.background': colors.bg,
+    'editorLineNumber.foreground': colors.textSubtle,
+    'editorLineNumber.activeForeground': colors.textMuted,
+    'editorCursor.foreground': colors.text,
+    'editor.lineHighlightBackground': colors.surface,
+    'editor.selectionBackground': withAlpha(colors.accent, 0.35),
+    'editor.inactiveSelectionBackground': withAlpha(colors.accent, 0.22),
+    'editorWidget.background': colors.surfaceElevated,
+    'editorWidget.border': colors.border,
+    'editorHoverWidget.background': colors.surfaceElevated,
+    'editorHoverWidget.border': colors.border,
+    'editorSuggestWidget.background': colors.surfaceElevated,
+    'editorSuggestWidget.border': colors.border,
+    focusBorder: colors.focusBorder,
+    'input.background': colors.surfaceElevated,
+    'input.border': colors.border,
+    'minimap.background': colors.bg,
+    'scrollbarSlider.background': colors.scrollbarThumb,
+    'scrollbarSlider.hoverBackground': colors.scrollbarThumbHover,
+    'scrollbarSlider.activeBackground': colors.scrollbarThumbActive,
+    'editorIndentGuide.background1': colors.border,
+    'editorIndentGuide.activeBackground1': colors.textMuted,
+    'editorWhitespace.foreground': colors.border,
+    'editorBracketMatch.background': colors.surfaceHover,
+    'editorBracketMatch.border': colors.textMuted,
+    'editorError.foreground': withAlpha(colors.danger, 0.7),
+    'editorWarning.foreground': withAlpha(colors.textMuted, 0.7),
+    'editorOverviewRuler.border': colors.bg,
+    'editorOverviewRuler.errorForeground': withAlpha(colors.danger, 0.35),
+    'editorOverviewRuler.warningForeground': withAlpha(colors.textMuted, 0.35),
+  };
+}
+
+export function resolveMonacoThemeRoot(root?: HTMLElement): HTMLElement | null {
+  if (root) {
+    return root;
+  }
+
+  if (typeof document === 'undefined') {
+    return null;
+  }
+
+  return document.documentElement;
+}
+
+export function defineMonacoWorkbenchTheme(
+  monacoInstance: typeof monaco,
+  resolvedTheme: MonacoWorkbenchResolvedTheme,
+  root?: HTMLElement,
+) {
+  const themeRoot = resolveMonacoThemeRoot(root);
+  if (!themeRoot) {
+    return;
+  }
+
+  const themeId = resolvedTheme === 'light' ? MONACO_LIGHT_THEME_ID : MONACO_DARK_THEME_ID;
+
+  monacoInstance.editor.defineTheme(themeId, {
+    base: resolvedTheme === 'light' ? 'vs' : 'vs-dark',
+    inherit: true,
+    rules: [],
+    colors: buildMonacoThemeColors(readWorkbenchThemeColors(themeRoot)),
+  });
+}
+
+export function monacoThemeForWorkspaceTheme(theme: MonacoWorkbenchResolvedTheme) {
+  return theme === 'light' ? MONACO_LIGHT_THEME_ID : MONACO_DARK_THEME_ID;
+}
+
+export function getWorkbenchThemeAppearanceSignature(root?: HTMLElement): string {
+  const themeRoot = resolveMonacoThemeRoot(root);
+  if (!themeRoot) {
+    return '';
+  }
+
+  return `${themeRoot.dataset.theme ?? ''}:${themeRoot.dataset.themePreset ?? ''}`;
+}

package/src/testing/vitestMock.tsx

@@ -0,0 +1,71 @@
+import { createElement, type ChangeEvent } from 'react';
+
+export interface MockWorkbenchMonacoEditorProps {
+  language?: string;
+  onChange?: (value?: string) => void;
+  path?: string;
+  theme?: string;
+  value?: string;
+}
+
+export function WorkbenchMonacoEditor({
+  language,
+  onChange,
+  path,
+  theme = 'dark',
+  value,
+}: MockWorkbenchMonacoEditorProps) {
+  return createElement('textarea', {
+    'data-language': language,
+    'data-path': path,
+    'data-theme': monacoThemeForWorkspaceTheme(theme),
+    'data-testid': 'monaco-editor',
+    value: value ?? '',
+    onChange: (event: ChangeEvent<HTMLTextAreaElement>) => onChange?.(event.currentTarget.value),
+  });
+}
+
+export const useMonacoWorkbenchThemeSync = () => undefined;
+export const prepareMonacoWorkbenchEditor = () => undefined;
+export const defineMonacoWorkbenchTheme = () => undefined;
+export const configureWorkspaceEditorTypeScriptDiagnostics = () => undefined;
+export const monacoThemeForWorkspaceTheme = (theme: string) =>
+  theme === 'light' ? MONACO_LIGHT_THEME_ID : MONACO_DARK_THEME_ID;
+export const MONACO_DARK_THEME_ID = 'workbench-kit-dark';
+export const MONACO_LIGHT_THEME_ID = 'workbench-kit-light';
+export const buildMonacoThemeColors = () => ({});
+export const getWorkbenchThemeAppearanceSignature = () => '';
+export const readWorkbenchThemeColors = () => ({});
+export const resolveMonacoThemeRoot = () => null;
+export const withAlpha = (color: string, _alpha?: number) => color;
+
+export const monaco = {
+  KeyMod: { CtrlCmd: 1 },
+  KeyCode: { KeyS: 1 },
+  editor: {
+    defineTheme: () => undefined,
+    setTheme: () => undefined,
+    onDidChangeMarkers: () => ({ dispose: () => undefined }),
+    getModelMarkers: () => [],
+  },
+};
+
+export const Editor = WorkbenchMonacoEditor;
+export const loader = { config: () => undefined };
+
+export function createWorkbenchMonacoMockModule(
+  renderEditor?: (props: MockWorkbenchMonacoEditorProps) => ReturnType<typeof createElement>,
+) {
+  const defaultRender = ({ value }: MockWorkbenchMonacoEditorProps) =>
+    createElement('div', { 'data-testid': 'monaco-editor' }, value ?? 'Mocked Monaco Editor');
+
+  return {
+    WorkbenchMonacoEditor: renderEditor ?? defaultRender,
+    useMonacoWorkbenchThemeSync: () => undefined,
+    prepareMonacoWorkbenchEditor: () => undefined,
+    monacoThemeForWorkspaceTheme: (theme: string) => theme,
+    MONACO_DARK_THEME_ID: 'workbench-kit-dark',
+    MONACO_LIGHT_THEME_ID: 'workbench-kit-light',
+    monaco,
+  };
+}

package/src/useMonacoWorkbenchThemeSync.ts

@@ -0,0 +1,47 @@
+import { useEffect, useState } from 'react';
+
+import { monaco } from './monaco-loader.js';
+import {
+  defineMonacoWorkbenchTheme,
+  getWorkbenchThemeAppearanceSignature,
+  monacoThemeForWorkspaceTheme,
+  type MonacoWorkbenchResolvedTheme,
+} from './monacoWorkbenchTheme.js';
+
+function useWorkbenchThemeAppearanceSignature(): string {
+  const [signature, setSignature] = useState(() => getWorkbenchThemeAppearanceSignature());
+
+  useEffect(() => {
+    if (typeof document === 'undefined') {
+      return undefined;
+    }
+
+    const root = document.documentElement;
+    const updateSignature = () => {
+      setSignature(getWorkbenchThemeAppearanceSignature(root));
+    };
+
+    updateSignature();
+
+    const observer = new MutationObserver(updateSignature);
+    observer.observe(root, {
+      attributes: true,
+      attributeFilter: ['data-theme', 'data-theme-preset'],
+    });
+
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+
+  return signature;
+}
+
+export function useMonacoWorkbenchThemeSync(resolvedTheme: MonacoWorkbenchResolvedTheme) {
+  const appearanceSignature = useWorkbenchThemeAppearanceSignature();
+
+  useEffect(() => {
+    defineMonacoWorkbenchTheme(monaco, resolvedTheme);
+    monaco.editor.setTheme(monacoThemeForWorkspaceTheme(resolvedTheme));
+  }, [appearanceSignature, resolvedTheme]);
+}

package/src/workspaceTypeScriptDiagnostics.ts

@@ -0,0 +1,59 @@
+import type * as Monaco from 'monaco-editor';
+
+let workspaceTypeScriptDiagnosticsConfigured = false;
+
+interface MonacoTypeScriptLanguageService {
+  JsxEmit: { React: number };
+  ModuleKind: { ESNext: number };
+  ModuleResolutionKind: { NodeJs: number };
+  ScriptTarget: { ESNext: number };
+  javascriptDefaults: {
+    setCompilerOptions: (options: Record<string, unknown>) => void;
+    setDiagnosticsOptions: (options: Record<string, unknown>) => void;
+    setEagerModelSync: (value: boolean) => void;
+  };
+  typescriptDefaults: {
+    setCompilerOptions: (options: Record<string, unknown>) => void;
+    setDiagnosticsOptions: (options: Record<string, unknown>) => void;
+    setEagerModelSync: (value: boolean) => void;
+  };
+}
+
+const workspaceTypeScriptDiagnosticsOptions = {
+  noSemanticValidation: true,
+  noSuggestionDiagnostics: true,
+};
+
+function getMonacoTypeScriptLanguageService(
+  monacoInstance: typeof Monaco,
+): MonacoTypeScriptLanguageService | undefined {
+  return monacoInstance.languages.typescript as unknown as MonacoTypeScriptLanguageService;
+}
+
+export function configureWorkspaceEditorTypeScriptDiagnostics(monacoInstance: typeof Monaco): void {
+  if (workspaceTypeScriptDiagnosticsConfigured) return;
+
+  const typescript = getMonacoTypeScriptLanguageService(monacoInstance);
+  if (!typescript) return;
+
+  const compilerOptions = {
+    allowJs: true,
+    allowNonTsExtensions: true,
+    esModuleInterop: true,
+    jsx: typescript.JsxEmit.React,
+    module: typescript.ModuleKind.ESNext,
+    moduleResolution: typescript.ModuleResolutionKind.NodeJs,
+    noEmit: true,
+    reactNamespace: 'React',
+    target: typescript.ScriptTarget.ESNext,
+  };
+
+  typescript.typescriptDefaults.setCompilerOptions(compilerOptions);
+  typescript.javascriptDefaults.setCompilerOptions(compilerOptions);
+  typescript.typescriptDefaults.setDiagnosticsOptions(workspaceTypeScriptDiagnosticsOptions);
+  typescript.javascriptDefaults.setDiagnosticsOptions(workspaceTypeScriptDiagnosticsOptions);
+  typescript.typescriptDefaults.setEagerModelSync(true);
+  typescript.javascriptDefaults.setEagerModelSync(true);
+
+  workspaceTypeScriptDiagnosticsConfigured = true;
+}