@theia/core 1.34.0-next.7 → 1.34.1

package/src/common/index.ts

@@ -14,35 +14,36 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-export * from './types';
-export * from './disposable';
-export * from './reference';
-export * from './event';
+export { environment } from '@theia/application-package/lib/environment';
+export * from './application-error';
 export * from './cancellation';
 export * from './command';
-export * from './menu';
-export * from './selection-service';
-export * from './objects';
-export * from './os';
-export * from './resource';
+export * from './contribution-filter';
 export * from './contribution-provider';
-export * from './path';
+export * from './disposable';
+export * from './event';
 export * from './logger';
-export * from './messaging';
+export * from './lsp-types';
+export * from './menu';
 export * from './message-rpc';
 export * from './message-service';
 export * from './message-service-protocol';
+export * from './messaging';
+export * from './nls';
+export * from './numbers';
+export * from './objects';
+export * from './os';
+export * from './path';
+export * from './performance';
 export * from './progress-service';
 export * from './progress-service-protocol';
 export * from './quick-pick-service';
+export * from './reference';
+export * from './resource';
 export * from './selection';
+export * from './selection-service';
 export * from './strings';
-export * from './application-error';
-export * from './lsp-types';
-export * from './contribution-filter';
-export * from './nls';
-export * from './numbers';
-export * from './performance';
+export * from './types';
+export { default as URI } from './uri';
+export * from './view-column';
 
-import { environment } from '@theia/application-package/lib/environment';
-export { environment };

package/src/common/keybinding.ts

@@ -13,6 +13,9 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
+
+import { isObject } from './types';
+
 /**
  * A Keybinding binds a specific key sequence ({@link Keybinding#keybinding}) to trigger a command ({@link Keybinding#command}). A Keybinding optionally may
  * define a "when clause" ({@link Keybinding#when}) to specify in which context it becomes active.
@@ -102,7 +105,7 @@ export namespace Keybinding {
 
     /* Determine whether object is a KeyBinding */
     export function is(arg: unknown): arg is Keybinding {
-        return !!arg && typeof arg === 'object' && 'command' in arg && 'keybinding' in arg;
+        return isObject(arg) && 'command' in arg && 'keybinding' in arg;
     }
 }
 
@@ -118,6 +121,6 @@ export interface RawKeybinding extends Omit<Keybinding, 'keybinding'> {
 
 export namespace RawKeybinding {
     export function is(candidate: unknown): candidate is RawKeybinding {
-        return typeof candidate === 'object' && !!candidate && 'command' in candidate && 'key' in candidate;
+        return isObject(candidate) && 'command' in candidate && 'key' in candidate;
     }
 }

package/src/common/keys.ts

@@ -15,6 +15,7 @@
 // *****************************************************************************
 
 import { isOSX } from './os';
+import { isObject } from './types';
 
 export type KeySequence = KeyCode[];
 export namespace KeySequence {
@@ -489,7 +490,7 @@ export namespace SpecialCases {
 export namespace Key {
 
     export function isKey(arg: unknown): arg is Key {
-        return !!arg && typeof arg === 'object' && 'code' in arg && 'keyCode' in arg;
+        return isObject(arg) && 'code' in arg && 'keyCode' in arg;
     }
 
     export function getKey(arg: string | number): Key | undefined {

package/src/common/lsp-types.ts

@@ -15,6 +15,7 @@
 // *****************************************************************************
 
 import { Range } from 'vscode-languageserver-protocol';
+import { isNumber, isObject, isString, isUndefined } from './types';
 
 export interface TextDocumentContentChangeDelta {
     readonly range: Range;
@@ -24,12 +25,10 @@ export interface TextDocumentContentChangeDelta {
 export namespace TextDocumentContentChangeDelta {
 
     export function is(arg: unknown): arg is TextDocumentContentChangeDelta {
-        const changeDelta = arg as TextDocumentContentChangeDelta;
-        return !!changeDelta
-            && typeof changeDelta === 'object'
-            && typeof changeDelta.text === 'string'
-            && (typeof changeDelta.rangeLength === 'number' || typeof changeDelta.rangeLength === 'undefined')
-            && Range.is(changeDelta.range);
+        return isObject<TextDocumentContentChangeDelta>(arg)
+            && isString(arg.text)
+            && (isNumber(arg.rangeLength) || isUndefined(arg.rangeLength))
+            && Range.is(arg.range);
     }
 
 }

package/src/common/markdown-rendering/markdown-string.ts

@@ -17,6 +17,7 @@
 import { escapeRegExpCharacters } from '../strings';
 import { UriComponents } from '../uri';
 import { escapeIcons } from './icon-utilities';
+import { isObject, isString } from '../types';
 
 export interface MarkdownString {
     readonly value: string;
@@ -37,8 +38,7 @@ export namespace MarkdownString {
      * @returns whether the candidate satisfies the interface of a markdown string
      */
     export function is(candidate: unknown): candidate is MarkdownString {
-        const maybeMarkdownString = candidate as MarkdownString;
-        return typeof maybeMarkdownString === 'object' && !!maybeMarkdownString && typeof maybeMarkdownString.value === 'string';
+        return isObject<MarkdownString>(candidate) && isString(candidate.value);
     }
 }
 

package/src/common/menu/menu-types.ts

@@ -15,6 +15,7 @@
 // *****************************************************************************
 
 import { Disposable } from '../disposable';
+import { isObject } from '../types';
 
 export type MenuPath = string[];
 export const MAIN_MENU_BAR: MenuPath = ['menubar'];
@@ -86,7 +87,7 @@ export interface MenuAction extends MenuNodeRenderingData, Pick<MenuNodeMetadata
 export namespace MenuAction {
     /* Determine whether object is a MenuAction */
     export function is(arg: unknown): arg is MenuAction {
-        return !!arg && typeof arg === 'object' && 'commandId' in arg;
+        return isObject(arg) && 'commandId' in arg;
     }
 }
 

package/src/common/message-service-protocol.ts

@@ -16,6 +16,7 @@
 
 import { injectable } from 'inversify';
 import { CancellationToken } from './cancellation';
+import { nls } from './nls';
 
 export const messageServicePath = '/services/messageService';
 
@@ -52,7 +53,7 @@ export interface ProgressMessage extends Message {
     readonly options?: ProgressMessageOptions;
 }
 export namespace ProgressMessage {
-    export const Cancel = 'Cancel';
+    export const Cancel = nls.localizeByDefault('Cancel');
     export function isCancelable(message: ProgressMessage): boolean {
         return !!message.options?.cancelable;
     }

package/src/common/objects.ts

@@ -14,8 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { isObject } from './types';
+
 export function deepClone<T>(obj: T): T {
-    if (!obj || typeof obj !== 'object') {
+    if (!isObject(obj)) {
         return obj;
     }
     if (obj instanceof RegExp) {
@@ -24,9 +26,8 @@ export function deepClone<T>(obj: T): T {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result: any = Array.isArray(obj) ? [] : {};
     Object.keys(obj).forEach((key: string) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const prop = (<any>obj)[key];
-        if (prop && typeof prop === 'object') {
+        const prop = obj[key];
+        if (isObject(prop)) {
             result[key] = deepClone(prop);
         } else {
             result[key] = prop;
@@ -36,7 +37,7 @@ export function deepClone<T>(obj: T): T {
 }
 
 export function deepFreeze<T>(obj: T): T {
-    if (!obj || typeof obj !== 'object') {
+    if (!isObject(obj)) {
         return obj;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -47,7 +48,7 @@ export function deepFreeze<T>(obj: T): T {
         for (const key in objectToFreeze) {
             if (_hasOwnProperty.call(objectToFreeze, key)) {
                 const prop = objectToFreeze[key];
-                if (typeof prop === 'object' && !Object.isFrozen(prop)) {
+                if (isObject(prop) && !Object.isFrozen(prop)) {
                     stack.push(prop);
                 }
             }

package/src/common/preferences/preference-schema.ts

@@ -19,6 +19,7 @@
 import { JSONValue } from '@phosphor/coreutils';
 import { IJSONSchema } from '../json-schema';
 import { PreferenceScope } from './preference-scope';
+import { isObject, isString } from '../types';
 
 export interface PreferenceSchema {
     [name: string]: any,
@@ -28,7 +29,7 @@ export interface PreferenceSchema {
 }
 export namespace PreferenceSchema {
     export function is(obj: unknown): obj is PreferenceSchema {
-        return !!obj && typeof obj === 'object' && ('properties' in obj) && PreferenceSchemaProperties.is((obj as PreferenceSchema).properties);
+        return isObject<PreferenceSchema>(obj) && PreferenceSchemaProperties.is(obj.properties);
     }
     export function getDefaultScope(schema: PreferenceSchema): PreferenceScope {
         let defaultScope: PreferenceScope = PreferenceScope.Workspace;
@@ -46,7 +47,7 @@ export interface PreferenceSchemaProperties {
 }
 export namespace PreferenceSchemaProperties {
     export function is(obj: unknown): obj is PreferenceSchemaProperties {
-        return !!obj && typeof obj === 'object';
+        return isObject(obj);
     }
 }
 
@@ -86,7 +87,7 @@ export namespace PreferenceDataProperty {
     export function fromPreferenceSchemaProperty(schemaProps: PreferenceSchemaProperty, defaultScope: PreferenceScope = PreferenceScope.Workspace): PreferenceDataProperty {
         if (!schemaProps.scope) {
             schemaProps.scope = defaultScope;
-        } else if (typeof schemaProps.scope === 'string') {
+        } else if (isString(schemaProps.scope)) {
             return Object.assign(schemaProps, { scope: PreferenceScope.fromString(schemaProps.scope) || defaultScope });
         }
         return <PreferenceDataProperty>schemaProps;

package/src/common/prioritizeable.ts

@@ -0,0 +1,58 @@
+// *****************************************************************************
+// Copyright (C) 2023 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import type { MaybeArray, MaybePromise } from './types';
+
+export interface Prioritizeable<T> {
+    readonly priority: number;
+    readonly value: T;
+}
+export namespace Prioritizeable {
+    export type GetPriority<T> = (value: T) => MaybePromise<number>;
+    export type GetPrioritySync<T> = (value: T) => number;
+    export async function toPrioritizeable<T>(rawValue: MaybePromise<T>, getPriority: GetPriority<T>): Promise<Prioritizeable<T>>;
+    export async function toPrioritizeable<T>(rawValue: MaybePromise<T>[], getPriority: GetPriority<T>): Promise<Prioritizeable<T>[]>;
+    export async function toPrioritizeable<T>(rawValue: MaybeArray<MaybePromise<T>>, getPriority: GetPriority<T>): Promise<MaybeArray<Prioritizeable<T>>> {
+        if (rawValue instanceof Array) {
+            return Promise.all(
+                rawValue.map(v => toPrioritizeable(v, getPriority))
+            );
+        }
+        const value = await rawValue;
+        const priority = await getPriority(value);
+        return { priority, value };
+    }
+    export function toPrioritizeableSync<T>(rawValue: T[], getPriority: GetPrioritySync<T>): Prioritizeable<T>[] {
+        return rawValue.map(v => ({
+            value: v,
+            priority: getPriority(v)
+        }));
+    }
+    export function prioritizeAllSync<T>(values: T[], getPriority: GetPrioritySync<T>): Prioritizeable<T>[] {
+        const prioritizeable = toPrioritizeableSync(values, getPriority);
+        return prioritizeable.filter(isValid).sort(compare);
+    }
+    export async function prioritizeAll<T>(values: MaybePromise<T>[], getPriority: GetPriority<T>): Promise<Prioritizeable<T>[]> {
+        const prioritizeable = await toPrioritizeable(values, getPriority);
+        return prioritizeable.filter(isValid).sort(compare);
+    }
+    export function isValid<T>(p: Prioritizeable<T>): boolean {
+        return p.priority > 0;
+    }
+    export function compare<T>(p: Prioritizeable<T>, p2: Prioritizeable<T>): number {
+        return p2.priority - p.priority;
+    }
+}

package/src/common/promise-util.ts

@@ -17,6 +17,7 @@
 import { Disposable } from './disposable';
 import { Event } from './event';
 import { CancellationToken, CancellationError, cancelled } from './cancellation';
+import { isFunction, isObject } from './types';
 
 /**
  * Simple implementation of the deferred pattern.
@@ -126,5 +127,5 @@ export function waitForEvent<T>(event: Event<T>, ms: number, thisArg?: any, disp
 }
 
 export function isThenable<T>(obj: unknown): obj is Promise<T> {
-    return typeof obj === 'object' && !!obj && typeof (obj as Promise<unknown>).then === 'function';
+    return isObject<Promise<unknown>>(obj) && isFunction(obj.then);
 }

package/src/common/selection.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { isObject } from './types';
 import URI from './uri';
 
 export interface UriSelection {
@@ -23,7 +24,7 @@ export interface UriSelection {
 export namespace UriSelection {
 
     export function is(arg: unknown): arg is UriSelection {
-        return !!arg && typeof arg === 'object' && ('uri' in arg) && (arg as UriSelection).uri instanceof URI;
+        return isObject<UriSelection>(arg) && arg.uri instanceof URI;
     }
 
     export function getUri(selection: unknown): URI | undefined {

package/src/common/types.ts

@@ -14,161 +14,81 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-export type Mutable<T> = { -readonly [P in keyof T]: T[P] };
-export type MaybeNull<T> = { [P in keyof T]: T[P] | null };
-export type MaybeUndefined<T> = { [P in keyof T]: T[P] | undefined };
-
-/**
- * Creates a shallow copy with all ownkeys of the original object that are `null` made `undefined`
- */
-export function nullToUndefined<T>(nullable: MaybeNull<T>): MaybeUndefined<T> {
-    const undefinable = { ...nullable } as MaybeUndefined<T>;
-    for (const key in nullable) {
-        // eslint-disable-next-line no-null/no-null
-        if (nullable[key] === null && Object.prototype.hasOwnProperty.call(nullable, key)) {
-            undefinable[key] = undefined;
-        }
-    }
-    return undefinable;
-}
+export { ArrayUtils } from './array-utils';
+export { Prioritizeable } from './prioritizeable';
 
-export type Deferred<T> = {
-    [P in keyof T]: Promise<T[P]>
-};
+export type Deferred<T> = { [P in keyof T]: Promise<T[P]> };
+export type MaybeArray<T> = T | T[];
+export type MaybeNull<T> = { [P in keyof T]: T[P] | null };
+export type MaybePromise<T> = T | PromiseLike<T>;
+export type MaybeUndefined<T> = { [P in keyof T]?: T[P] | undefined };
+export type Mutable<T> = { -readonly [P in keyof T]: T[P] };
 export type RecursivePartial<T> = {
-    [P in keyof T]?: T[P] extends Array<infer I>
-    ? Array<RecursivePartial<I>>
+    [P in keyof T]?: T[P] extends (infer I)[]
+    ? RecursivePartial<I>[]
     : RecursivePartial<T[P]>;
 };
-export type MaybeArray<T> = T | T[];
-export type MaybePromise<T> = T | PromiseLike<T>;
 
-export interface Prioritizeable<T> {
-    readonly priority: number;
-    readonly value: T;
-}
-export namespace Prioritizeable {
-    export type GetPriority<T> = (value: T) => MaybePromise<number>;
-    export type GetPrioritySync<T> = (value: T) => number;
-    export async function toPrioritizeable<T>(rawValue: MaybePromise<T>, getPriority: GetPriority<T>): Promise<Prioritizeable<T>>;
-    export async function toPrioritizeable<T>(rawValue: MaybePromise<T>[], getPriority: GetPriority<T>): Promise<Prioritizeable<T>[]>;
-    export async function toPrioritizeable<T>(rawValue: MaybeArray<MaybePromise<T>>, getPriority: GetPriority<T>): Promise<MaybeArray<Prioritizeable<T>>> {
-        if (rawValue instanceof Array) {
-            return Promise.all(
-                rawValue.map(v => toPrioritizeable(v, getPriority))
-            );
-        }
-        const value = await rawValue;
-        const priority = await getPriority(value);
-        return { priority, value };
-    }
-    export function toPrioritizeableSync<T>(rawValue: T[], getPriority: GetPrioritySync<T>): Prioritizeable<T>[] {
-        return rawValue.map(v => ({
-            value: v,
-            priority: getPriority(v)
-        }));
-    }
-    export function prioritizeAllSync<T>(values: T[], getPriority: GetPrioritySync<T>): Prioritizeable<T>[] {
-        const prioritizeable = toPrioritizeableSync(values, getPriority);
-        return prioritizeable.filter(isValid).sort(compare);
-    }
-    export async function prioritizeAll<T>(values: MaybePromise<T>[], getPriority: GetPriority<T>): Promise<Prioritizeable<T>[]> {
-        const prioritizeable = await toPrioritizeable(values, getPriority);
-        return prioritizeable.filter(isValid).sort(compare);
-    }
-    export function isValid<T>(p: Prioritizeable<T>): boolean {
-        return p.priority > 0;
-    }
-    export function compare<T>(p: Prioritizeable<T>, p2: Prioritizeable<T>): number {
-        return p2.priority - p.priority;
-    }
+export function isBoolean(value: unknown): value is boolean {
+    return value === true || value === false;
 }
 
-export namespace ArrayUtils {
-    export interface Head<T> extends Array<T> {
-        head(): T;
-    }
-
-    export interface Tail<T> extends Array<T> {
-        tail(): T;
-    }
-
-    export interface Children<T> extends Array<T> {
-        children(): Tail<T>
-    }
+export function isString(value: unknown): value is string {
+    return typeof value === 'string' || value instanceof String;
+}
 
-    export const TailImpl = {
-        tail<T>(this: Array<T>): T {
-            return this[this.length - 1];
-        },
-    };
+export function isNumber(value: unknown): value is number {
+    return typeof value === 'number' || value instanceof Number;
+}
 
-    export const HeadAndChildrenImpl = {
-        head<T>(this: Array<T>): T {
-            return this[0];
-        },
+export function isError(value: unknown): value is Error {
+    return value instanceof Error;
+}
 
-        children<T>(this: Array<T>): Tail<T> {
-            return Object.assign(this.slice(1), TailImpl);
-        }
-    };
+export function isErrorLike(value: unknown): value is Error {
+    return isObject(value) && isString(value.name) && isString(value.message) && (isUndefined(value.stack) || isString(value.stack));
+}
 
-    export interface HeadAndTail<T> extends Head<T>, Tail<T>, Children<T> { }
+// eslint-disable-next-line space-before-function-paren
+export function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T {
+    return typeof value === 'function';
+}
 
-    export function asTail<T>(array: Array<T>): Tail<T> {
-        return Object.assign(array, TailImpl);
-    }
+export function isObject<T = Record<string | number | symbol, unknown>>(value: unknown): value is T {
+    // eslint-disable-next-line no-null/no-null
+    return typeof value === 'object' && value !== null;
+}
 
-    export function asHeadAndTail<T>(array: Array<T>): HeadAndTail<T> {
-        return Object.assign(array, HeadAndChildrenImpl, TailImpl);
-    }
+export function isUndefined(value: unknown): value is undefined {
+    return typeof value === 'undefined';
+}
 
-    export enum Sort {
-        LeftBeforeRight = -1,
-        RightBeforeLeft = 1,
-        Equal = 0,
-    }
+/**
+ * @param value value to check.
+ * @param every optional predicate ran on every element of the array.
+ * @param thisArg value to substitute `this` with when invoking in the predicate.
+ * @returns whether or not `value` is an array.
+ */
+export function isArray<T>(value: unknown, every?: (value: unknown) => unknown, thisArg?: unknown): value is T[] {
+    return Array.isArray(value) && (!isFunction(every) || value.every(every, thisArg));
+}
 
-    // Copied from https://github.com/microsoft/vscode/blob/9c29becfad5f68270b9b23efeafb147722c5feba/src/vs/base/common/arrays.ts
-    /**
-     * Performs a binary search algorithm over a sorted collection. Useful for cases
-     * when we need to perform a binary search over something that isn't actually an
-     * array, and converting data to an array would defeat the use of binary search
-     * in the first place.
-     *
-     * @param length The collection length.
-     * @param compareToKey A function that takes an index of an element in the
-     *   collection and returns zero if the value at this index is equal to the
-     *   search key, a negative number if the value precedes the search key in the
-     *   sorting order, or a positive number if the search key precedes the value.
-     * @return A non-negative index of an element, if found. If not found, the
-     *   result is -(n+1) (or ~n, using bitwise notation), where n is the index
-     *   where the key should be inserted to maintain the sorting order.
-     */
-    export function binarySearch2(length: number, compareToKey: (index: number) => number): number {
-        let low = 0;
-        let high = length - 1;
+export function isStringArray(value: unknown): value is string[] {
+    return isArray(value, isString);
+}
 
-        while (low <= high) {
-            const mid = ((low + high) / 2) | 0;
-            const comp = compareToKey(mid);
-            if (comp < 0) {
-                low = mid + 1;
-            } else if (comp > 0) {
-                high = mid - 1;
-            } else {
-                return mid;
-            }
+/**
+ * Creates a shallow copy with all ownkeys of the original object that are `null` made `undefined`
+ */
+export function nullToUndefined<T>(nullable: MaybeNull<T>): MaybeUndefined<T> {
+    const undefinable = { ...nullable } as MaybeUndefined<T>;
+    for (const key in nullable) {
+        // eslint-disable-next-line no-null/no-null
+        if (nullable[key] === null && Object.prototype.hasOwnProperty.call(nullable, key)) {
+            undefinable[key] = undefined;
         }
-        return -(low + 1);
-    }
-
-    /**
-     * @returns New array with all falsy values removed. The original array IS NOT modified.
-     */
-    export function coalesce<T>(array: ReadonlyArray<T | undefined | null>): T[] {
-        return <T[]>array.filter(e => !!e);
     }
+    return undefinable;
 }
 
 /**

package/src/common/uri-command-handler.ts

@@ -20,7 +20,7 @@ import { SelectionService } from '../common/selection-service';
 import { UriSelection } from '../common/selection';
 import { CommandHandler } from './command';
 import URI from './uri';
-import { MaybeArray } from './types';
+import { isArray, MaybeArray } from './types';
 
 export interface UriCommandHandler<T extends MaybeArray<URI>> extends CommandHandler {
 
@@ -59,7 +59,7 @@ export class UriAwareCommandHandler<T extends MaybeArray<URI>> implements UriCom
     protected getUri(...args: any[]): T | undefined {
         const [maybeUriArray] = args;
         const firstArgIsOK = this.isMulti()
-            ? Array.isArray(maybeUriArray) && maybeUriArray.every(uri => uri instanceof URI)
+            ? isArray(maybeUriArray, uri => uri instanceof URI)
             : maybeUriArray instanceof URI;
 
         if (firstArgIsOK) {

package/src/common/uri.ts

@@ -23,6 +23,10 @@ export class URI {
         return new URI(Uri.revive(components));
     }
 
+    public static fromFilePath(path: string): URI {
+        return new URI(Uri.file(path));
+    }
+
     private readonly codeUri: Uri;
     private _path: Path | undefined;
 

package/src/common/view-column.ts

@@ -0,0 +1,33 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/**
+ * Denotes a column in the editor window.
+ * Columns are used to show editors side by side.
+ */
+export enum ViewColumn {
+    Active = -1,
+    Beside = -2,
+    One = 1,
+    Two = 2,
+    Three = 3,
+    Four = 4,
+    Five = 5,
+    Six = 6,
+    Seven = 7,
+    Eight = 8,
+    Nine = 9
+}