@opensumi/ide-debug 2.24.6-rc-1685671765.0 → 2.25.0

package/src/browser/preferences/components/select-widget.tsx

@@ -0,0 +1,68 @@
+import {
+  descriptionId,
+  FormContextType,
+  getTemplate,
+  RJSFSchema,
+  StrictRJSFSchema,
+  titleId,
+  WidgetProps,
+} from '@rjsf/utils';
+import React, { useMemo } from 'react';
+
+import { Option, Select } from '@opensumi/ide-components';
+
+import styles from './json-widget.module.less';
+
+export const SelectWidget = <T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  props: WidgetProps<T, S, F>,
+) => {
+  const { schema, value, id, registry, uiOptions, name, required, onChange } = props;
+  const description = schema.description;
+
+  const TitleFieldTemplate = getTemplate<'TitleFieldTemplate', T, S, F>('TitleFieldTemplate', registry, uiOptions);
+  const DescriptionFieldTemplate = getTemplate<'DescriptionFieldTemplate', T, S, F>(
+    'DescriptionFieldTemplate',
+    registry,
+    uiOptions,
+  );
+
+  const enumValue = useMemo(() => {
+    if (schema && schema.enum) {
+      return schema.enum;
+    }
+    return [];
+  }, [schema, schema.enum]);
+
+  return (
+    <div className={styles.select_widget_control}>
+      {name && (
+        <div className={styles.object_title}>
+          <TitleFieldTemplate
+            id={titleId<T>(id)}
+            title={name}
+            required={required}
+            schema={schema}
+            registry={registry}
+          />
+        </div>
+      )}
+      {description && (
+        <div className={styles.object_description}>
+          <DescriptionFieldTemplate
+            id={descriptionId<T>(id)}
+            description={description}
+            schema={schema}
+            registry={registry}
+          />
+        </div>
+      )}
+      <Select key={id} value={value} dropdownRenderType='absolute' onChange={onChange}>
+        {enumValue.map((data: string) => (
+          <Option value={data} label={data} key={data}>
+            {data}
+          </Option>
+        ))}
+      </Select>
+    </div>
+  );
+};

package/src/browser/preferences/components/text-widget.tsx

@@ -0,0 +1,114 @@
+import {
+  descriptionId,
+  FormContextType,
+  GenericObjectType,
+  getTemplate,
+  RJSFSchema,
+  StrictRJSFSchema,
+  titleId,
+  WidgetProps,
+} from '@rjsf/utils';
+import React, { useMemo } from 'react';
+
+import { Input } from '@opensumi/ide-components';
+
+import { parseSnippet } from '../../debugUtils';
+
+import styles from './json-widget.module.less';
+
+export const TextWidget = <T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  props: WidgetProps<T, S, F>,
+) => {
+  const {
+    disabled,
+    formContext,
+    id,
+    onBlur,
+    onChange,
+    onFocus,
+    options,
+    placeholder,
+    readonly,
+    schema,
+    value,
+    registry,
+    label,
+    hideLabel,
+    required,
+    uiSchema,
+    uiOptions,
+  } = props;
+  const { readonlyAsDisabled = true } = formContext as GenericObjectType;
+
+  const TitleFieldTemplate = getTemplate<'TitleFieldTemplate', T, S, F>('TitleFieldTemplate', registry, uiOptions);
+  const DescriptionFieldTemplate = getTemplate<'DescriptionFieldTemplate', T, S, F>(
+    'DescriptionFieldTemplate',
+    registry,
+    uiOptions,
+  );
+
+  const parseValue = useMemo(() => {
+    if (typeof value !== 'string') {
+      return value;
+    }
+
+    return parseSnippet(value);
+  }, [value]);
+
+  const handleBlur = ({ target }: React.FocusEvent<HTMLInputElement>) => {
+    onChange(target.value === '' ? options.emptyValue : target.value);
+    onBlur(id, target.value);
+  };
+
+  const handleFocus = ({ target }: React.FocusEvent<HTMLInputElement>) => onFocus(id, target.value);
+
+  const type = useMemo(() => {
+    if (schema.type !== 'string' && schema.type !== 'number') {
+      return 'string';
+    }
+
+    return schema.type;
+  }, [schema, schema.type]);
+
+  const description = useMemo(() => schema.description || '', [schema, schema.description]);
+
+  return (
+    <div>
+      {!hideLabel && label && (
+        <div className={styles.object_title}>
+          <TitleFieldTemplate
+            id={titleId<T>(id)}
+            title={label}
+            required={required}
+            schema={schema}
+            uiSchema={uiSchema}
+            registry={registry}
+          />
+        </div>
+      )}
+      {description && (
+        <div className={styles.object_description}>
+          <DescriptionFieldTemplate
+            id={descriptionId<T>(id)}
+            description={description}
+            schema={schema}
+            uiSchema={uiSchema}
+            registry={registry}
+          />
+        </div>
+      )}
+      <Input
+        disabled={disabled || (readonlyAsDisabled && readonly)}
+        id={id}
+        name={id}
+        onBlur={!readonly ? handleBlur : undefined}
+        onFocus={!readonly ? handleFocus : undefined}
+        placeholder={placeholder}
+        type={type}
+        value={parseValue}
+        className={styles.text_widget_control}
+        autoComplete='off'
+      />
+    </div>
+  );
+};

package/src/browser/preferences/launch-preferences-contribution.ts

@@ -1,9 +1,90 @@
-import { PreferenceContribution, PreferenceSchema, Domain, PreferenceConfiguration } from '@opensumi/ide-core-browser';
+import { Autowired, Injectable } from '@opensumi/di';
+import {
+  PreferenceContribution,
+  PreferenceSchema,
+  Domain,
+  PreferenceConfiguration,
+  URI,
+  MaybePromise,
+  localize,
+  getIcon,
+  COMMON_COMMANDS,
+} from '@opensumi/ide-core-browser';
+import { IMenuRegistry, MenuContribution } from '@opensumi/ide-core-browser/lib/menu/next/base';
+import { MenuId } from '@opensumi/ide-core-browser/lib/menu/next/menu-id';
+import {
+  BrowserEditorContribution,
+  EditorComponentRegistry,
+  EditorOpenType,
+  IResource,
+  IResourceProvider,
+  ResourceService,
+} from '@opensumi/ide-editor/lib/browser';
+
+import { LAUNCH_VIEW_COMPONENT_ID, LAUNCH_VIEW_SCHEME } from '../../common/constants';
 
 import { launchPreferencesSchema } from './launch-preferences';
+import { LaunchViewContainer } from './launch.view';
+
+@Injectable()
+export class LaunchResourceProvider implements IResourceProvider {
+  readonly scheme: string = LAUNCH_VIEW_SCHEME;
+
+  provideResource(uri: URI): MaybePromise<IResource<any>> {
+    return {
+      supportsRevive: true,
+      name: localize('menu-bar.title.debug'),
+      icon: getIcon('debug'),
+      uri,
+    };
+  }
+
+  provideResourceSubname(): string | null {
+    return null;
+  }
+
+  async shouldCloseResource(): Promise<boolean> {
+    return true;
+  }
+}
+
+@Domain(PreferenceContribution, PreferenceConfiguration, BrowserEditorContribution, MenuContribution)
+export class LaunchPreferencesContribution
+  implements PreferenceContribution, PreferenceConfiguration, BrowserEditorContribution, MenuContribution
+{
+  @Autowired(LaunchResourceProvider)
+  private readonly prefResourceProvider: LaunchResourceProvider;
 
-@Domain(PreferenceContribution, PreferenceConfiguration)
-export class LaunchPreferencesContribution implements PreferenceContribution, PreferenceConfiguration {
   schema: PreferenceSchema = launchPreferencesSchema;
   name = 'launch';
+
+  registerResource(resourceService: ResourceService): void {
+    resourceService.registerResourceProvider(this.prefResourceProvider);
+  }
+
+  registerEditorComponent(editorComponentRegistry: EditorComponentRegistry): void {
+    editorComponentRegistry.registerEditorComponent({
+      component: LaunchViewContainer,
+      uid: LAUNCH_VIEW_COMPONENT_ID,
+      scheme: LAUNCH_VIEW_SCHEME,
+    });
+
+    editorComponentRegistry.registerEditorComponentResolver(LAUNCH_VIEW_SCHEME, (_, __, resolve) => {
+      resolve([
+        {
+          type: EditorOpenType.component,
+          componentId: LAUNCH_VIEW_COMPONENT_ID,
+        },
+      ]);
+    });
+  }
+
+  registerMenus(menus: IMenuRegistry) {
+    menus.registerMenuItem(MenuId.EditorTitle, {
+      command: COMMON_COMMANDS.OPEN_LAUNCH_CONFIGURATION.id,
+      iconClass: getIcon('open'),
+      group: 'navigation',
+      when: `resourceScheme == ${LAUNCH_VIEW_SCHEME}`,
+    });
+  }
 }

package/src/browser/preferences/launch.module.less

@@ -0,0 +1,102 @@
+@base-font-size: 14px;
+@small-base-font-size: 12px;
+
+.launch_container {
+  height: 100%;
+  font-size: @base-font-size;
+  overflow: hidden;
+  padding: 16px 16px 0 16px;
+  box-sizing: border-box;
+  min-width: 500px;
+
+  .no_onfiguration {
+    padding: 0 16px;
+  }
+
+  .launch_panel {
+    height: 100%;
+    margin-top: 8px;
+
+    .launch_indexes_container {
+      height: 100%;
+      margin-right: 16px;
+      .not_configuration_content {
+        text-align: center;
+        font-size: @small-base-font-size;
+      }
+      .configuration_items_box {
+        height: calc(100% - 50px) !important;
+        .configuration_item {
+          height: 26px;
+          display: flex;
+          align-items: center;
+          cursor: pointer;
+          flex-direction: row;
+          padding: 4px 8px;
+
+          &:hover {
+            background: var(--list-hoverBackground);
+            color: var(--list-hoverForeground);
+          }
+          &.selected {
+            background: var(--kt-tree-inactiveSelectionBackground);
+            color: var(--list-activeSelectionForeground);
+          }
+
+          .configuration_wrapper {
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            flex: 1;
+          }
+
+          .configuration_description {
+            display: inline;
+            font-size: 12px;
+          }
+        }
+      }
+      .foot_box {
+        position: relative;
+        z-index: 1;
+        .button {
+          width: 100%;
+        }
+      }
+    }
+
+    .launch_schema_body_container {
+      overflow: auto;
+      height: 100%;
+      padding: 0 16px 22px 0px;
+    }
+  }
+}
+
+.devider {
+  box-sizing: border-box;
+  font-size: 14px;
+  font-variant: tabular-nums;
+  list-style: none;
+  font-feature-settings: 'tnum';
+  position: relative;
+  margin: 0 3px;
+  display: inline-block;
+  vertical-align: middle;
+  &:after {
+    content: '';
+    display: block;
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    width: 100%;
+    height: 100%;
+    border-top: 0;
+    border-left: 1px solid var(--editorGroup-border);
+    pointer-events: none;
+    transform: translateX(1.5px);
+  }
+  &:hover:after {
+    border-color: transparent;
+  }
+}

package/src/browser/preferences/launch.service.ts

@@ -0,0 +1,133 @@
+import { IChangeEvent } from '@rjsf/core';
+import { GenericObjectType, StrictRJSFSchema } from '@rjsf/utils';
+import * as jsoncparser from 'jsonc-parser';
+import lodashSet from 'lodash/set';
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { Emitter, Event, FileType, IJSONSchema, URI } from '@opensumi/ide-core-common';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import { ILaunchService } from '../../common/debug-service';
+
+type TFormData = { [key in string]: any };
+const CONFIGURATIONS_FIELD = 'configurations';
+
+@Injectable()
+export class LaunchService implements ILaunchService {
+  @Autowired(IFileServiceClient)
+  private readonly fileSystem: IFileServiceClient;
+
+  private readonly _onRawSchemaProperties = new Emitter<IJSONSchema>();
+  public readonly onRawSchemaProperties: Event<IJSONSchema> = this._onRawSchemaProperties.event;
+
+  private readonly _onChangeSchema = new Emitter<StrictRJSFSchema>();
+  public readonly onChangeSchema: Event<StrictRJSFSchema> = this._onChangeSchema.event;
+
+  private readonly _onChangeFormData = new Emitter<TFormData>();
+  public readonly onChangeFormData: Event<TFormData> = this._onChangeFormData.event;
+
+  private _rawSchemaProperties: IJSONSchema;
+  private _schema: StrictRJSFSchema;
+  private _formData: TFormData;
+
+  public get rawSchemaProperties(): IJSONSchema {
+    return this._rawSchemaProperties;
+  }
+  public get schema(): StrictRJSFSchema {
+    return this._schema;
+  }
+  public get formData(): TFormData {
+    return this._formData;
+  }
+
+  public setRawSchemaProperties(sp: IJSONSchema) {
+    this._rawSchemaProperties = sp;
+    this._onRawSchemaProperties.fire(sp);
+  }
+
+  public nextNewSchema(data: StrictRJSFSchema): void {
+    this._schema = data;
+    this._onChangeSchema.fire(data);
+  }
+
+  public nextNewFormData(data: TFormData, isEmit = true): void {
+    this._formData = data;
+    if (isEmit) {
+      this._onChangeFormData.fire(data);
+    }
+  }
+
+  public addNewItem(name: string): void {
+    if (name === '') {
+      return;
+    }
+
+    const { properties } = this.rawSchemaProperties;
+    const newFormData = { ...this.formData };
+
+    const preSchemaValue = properties![name];
+
+    lodashSet(newFormData as GenericObjectType, name, preSchemaValue['default'] || '');
+    lodashSet(this.schema.properties!, name, preSchemaValue);
+
+    this.nextNewSchema(this.schema);
+    this.nextNewFormData(newFormData);
+  }
+
+  public delItem(name: string): void {
+    if (name === '') {
+      return;
+    }
+
+    const { properties } = this.schema;
+    const newFormData = { ...this.formData };
+
+    delete newFormData[name];
+    delete properties![name];
+
+    this.nextNewSchema(this.schema);
+    this.nextNewFormData(newFormData);
+  }
+
+  private async readResourceContent(resource: URI): Promise<string> {
+    try {
+      const { content } = await this.fileSystem.readFile(resource.toString());
+      return content.toString();
+    } catch (error) {
+      return '';
+    }
+  }
+
+  public async modifyConfigurationsInResource(resource: URI, data: IChangeEvent, index: number): Promise<void> {
+    const stat = await this.fileSystem.getFileStat(resource.toString());
+
+    if (stat && stat.type === FileType.File) {
+      const { formData } = data;
+
+      const fileContent = await this.readResourceContent(resource);
+
+      const parseContent = jsoncparser.parse(fileContent);
+      const preConfigurations = parseContent[CONFIGURATIONS_FIELD];
+
+      if (!preConfigurations) {
+        return;
+      }
+
+      if (Array.isArray(preConfigurations) && preConfigurations.length - 1 >= index) {
+        preConfigurations.splice(index, 1, formData);
+      }
+
+      const edits = jsoncparser.modify(fileContent, [CONFIGURATIONS_FIELD], preConfigurations, {
+        isArrayInsertion: false,
+        formattingOptions: {
+          tabSize: 2,
+          insertSpaces: true,
+          eol: '\n',
+        },
+      });
+
+      const newContent = jsoncparser.applyEdits(fileContent, edits);
+      await this.fileSystem.setContent(stat, newContent);
+    }
+  }
+}