@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/colorRegistry.d.ts

@@ -0,0 +1,710 @@
+import { S as ServiceIdentifier, a as ServicesAccessor } from './instantiation.js';
+import { E as Event, I as IDisposable } from './event.js';
+import { I as IJSONSchema } from './jsonSchema.js';
+import { S as Severity$1 } from './extensions.d2.ts';
+
+type TypeConstraint = string | Function;
+
+interface ICommandEvent {
+    commandId: string;
+    args: any[];
+}
+
+declare const ICommandService: ServiceIdentifier<ICommandService>;
+interface ICommandService {
+    readonly _serviceBrand: undefined;
+    onWillExecuteCommand: Event<ICommandEvent>;
+    onDidExecuteCommand: Event<ICommandEvent>;
+    executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T | undefined>;
+}
+type ICommandsMap = Map<string, ICommand>;
+interface ICommandHandler {
+    (accessor: ServicesAccessor, ...args: any[]): void;
+}
+interface ICommand {
+    id: string;
+    handler: ICommandHandler;
+    description?: ICommandHandlerDescription | null;
+}
+interface ICommandHandlerDescription {
+    readonly description: string;
+    readonly args: ReadonlyArray<{
+        readonly name: string;
+        readonly isOptional?: boolean;
+        readonly description?: string;
+        readonly constraint?: TypeConstraint;
+        readonly schema?: IJSONSchema;
+    }>;
+    readonly returns?: string;
+}
+interface ICommandRegistry {
+    onDidRegisterCommand: Event<string>;
+    registerCommand(id: string, command: ICommandHandler): IDisposable;
+    registerCommand(command: ICommand): IDisposable;
+    registerCommandAlias(oldId: string, newId: string): IDisposable;
+    getCommand(id: string): ICommand | undefined;
+    getCommands(): ICommandsMap;
+}
+declare const CommandsRegistry: ICommandRegistry;
+
+declare class RGBA {
+    _rgbaBrand: void;
+    /**
+     * Red: integer in [0-255]
+     */
+    readonly r: number;
+    /**
+     * Green: integer in [0-255]
+     */
+    readonly g: number;
+    /**
+     * Blue: integer in [0-255]
+     */
+    readonly b: number;
+    /**
+     * Alpha: float in [0-1]
+     */
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    static equals(a: RGBA, b: RGBA): boolean;
+}
+declare class HSLA {
+    _hslaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Luminosity: float in [0, 1]
+     */
+    readonly l: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, l: number, a: number);
+    static equals(a: HSLA, b: HSLA): boolean;
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+    static fromRGBA(rgba: RGBA): HSLA;
+    private static _hue2rgb;
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+    static toRGBA(hsla: HSLA): RGBA;
+}
+declare class HSVA {
+    _hsvaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Value: float in [0, 1]
+     */
+    readonly v: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, v: number, a: number);
+    static equals(a: HSVA, b: HSVA): boolean;
+    static fromRGBA(rgba: RGBA): HSVA;
+    static toRGBA(hsva: HSVA): RGBA;
+}
+declare class Color {
+    static fromHex(hex: string): Color;
+    static equals(a: Color | null, b: Color | null): boolean;
+    readonly rgba: RGBA;
+    private _hsla?;
+    get hsla(): HSLA;
+    private _hsva?;
+    get hsva(): HSVA;
+    constructor(arg: RGBA | HSLA | HSVA);
+    equals(other: Color | null): boolean;
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+    getRelativeLuminance(): number;
+    private static _relativeLuminanceForComponent;
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    getContrastRatio(another: Color): number;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+    isDarker(): boolean;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+    isLighter(): boolean;
+    isLighterThan(another: Color): boolean;
+    isDarkerThan(another: Color): boolean;
+    lighten(factor: number): Color;
+    darken(factor: number): Color;
+    transparent(factor: number): Color;
+    isTransparent(): boolean;
+    isOpaque(): boolean;
+    opposite(): Color;
+    blend(c: Color): Color;
+    makeOpaque(opaqueBackground: Color): Color;
+    flatten(...backgrounds: Color[]): Color;
+    private static _flatten;
+    private _toString?;
+    toString(): string;
+    static getLighterColor(of: Color, relative: Color, factor?: number): Color;
+    static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
+    static readonly white: Color;
+    static readonly black: Color;
+    static readonly red: Color;
+    static readonly blue: Color;
+    static readonly green: Color;
+    static readonly cyan: Color;
+    static readonly lightgrey: Color;
+    static readonly transparent: Color;
+}
+declare namespace Color {
+    namespace Format {
+        namespace CSS {
+            function formatRGB(color: Color): string;
+            function formatRGBA(color: Color): string;
+            function formatHSL(color: Color): string;
+            function formatHSLA(color: Color): string;
+            /**
+             * Formats the color as #RRGGBB
+             */
+            function formatHex(color: Color): string;
+            /**
+             * Formats the color as #RRGGBBAA
+             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
+             */
+            function formatHexA(color: Color, compact?: boolean): string;
+            /**
+             * The default format will use HEX if opaque and RGBA otherwise.
+             */
+            function format(color: Color): string;
+            /**
+             * Converts an Hex color value to a Color.
+             * returns r, g, and b are contained in the set [0, 255]
+             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
+             */
+            function parseHex(hex: string): Color | null;
+        }
+    }
+}
+
+interface IAction {
+    readonly id: string;
+    label: string;
+    tooltip: string;
+    class: string | undefined;
+    enabled: boolean;
+    checked?: boolean;
+    run(...args: unknown[]): unknown;
+}
+interface IActionRunner extends IDisposable {
+    readonly onDidRun: Event<IRunEvent>;
+    readonly onWillRun: Event<IRunEvent>;
+    run(action: IAction, context?: unknown): unknown;
+}
+interface IRunEvent {
+    readonly action: IAction;
+    readonly error?: Error;
+}
+declare class SubmenuAction implements IAction {
+    readonly id: string;
+    readonly label: string;
+    readonly class: string | undefined;
+    readonly tooltip: string;
+    readonly enabled: boolean;
+    readonly checked: undefined;
+    private readonly _actions;
+    get actions(): readonly IAction[];
+    constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string);
+    run(): Promise<void>;
+}
+
+type Severity = Severity$1;
+type NotificationMessage = string | Error;
+declare enum NotificationPriority {
+    /**
+     * Default priority: notification will be visible unless do not disturb mode is enabled.
+     */
+    DEFAULT = 0,
+    /**
+     * Silent priority: notification will only be visible from the notifications center.
+     */
+    SILENT = 1,
+    /**
+     * Urgent priority: notification will be visible even when do not disturb mode is enabled.
+     */
+    URGENT = 2
+}
+interface INotificationProperties {
+    /**
+     * Sticky notifications are not automatically removed after a certain timeout.
+     *
+     * Currently, only 2 kinds of notifications are sticky:
+     * - Error notifications with primary actions
+     * - Notifications that show progress
+     */
+    readonly sticky?: boolean;
+    /**
+     * Allows to override the priority of the notification based on needs.
+     */
+    readonly priority?: NotificationPriority;
+    /**
+     * Adds an action to never show the notification again. The choice will be persisted
+     * such as future requests will not cause the notification to show again.
+     */
+    readonly neverShowAgain?: INeverShowAgainOptions;
+}
+declare enum NeverShowAgainScope {
+    /**
+     * Will never show this notification on the current workspace again.
+     */
+    WORKSPACE = 0,
+    /**
+     * Will never show this notification on any workspace of the same
+     * profile again.
+     */
+    PROFILE = 1,
+    /**
+     * Will never show this notification on any workspace across all
+     * profiles again.
+     */
+    APPLICATION = 2
+}
+interface INeverShowAgainOptions {
+    /**
+     * The id is used to persist the selection of not showing the notification again.
+     */
+    readonly id: string;
+    /**
+     * By default the action will show up as primary action. Setting this to true will
+     * make it a secondary action instead.
+     */
+    readonly isSecondary?: boolean;
+    /**
+     * Whether to persist the choice in the current workspace or for all workspaces. By
+     * default it will be persisted for all workspaces across all profiles
+     * (= `NeverShowAgainScope.APPLICATION`).
+     */
+    readonly scope?: NeverShowAgainScope;
+}
+interface INotification extends INotificationProperties {
+    /**
+     * The id of the notification. If provided, will be used to compare
+     * notifications with others to decide whether a notification is
+     * duplicate or not.
+     */
+    readonly id?: string;
+    /**
+     * The severity of the notification. Either `Info`, `Warning` or `Error`.
+     */
+    readonly severity: Severity;
+    /**
+     * The message of the notification. This can either be a `string` or `Error`. Messages
+     * can optionally include links in the format: `[text](link)`
+     */
+    readonly message: NotificationMessage;
+    /**
+     * The source of the notification appears as additional information.
+     */
+    readonly source?: string | {
+        label: string;
+        id: string;
+    };
+    /**
+     * Actions to show as part of the notification. Primary actions show up as
+     * buttons as part of the message and will close the notification once clicked.
+     *
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     *
+     * **Note:** If your intent is to show a message with actions to the user, consider
+     * the `INotificationService.prompt()` method instead which are optimized for
+     * this usecase and much easier to use!
+     */
+    actions?: INotificationActions;
+    /**
+     * The initial set of progress properties for the notification. To update progress
+     * later on, access the `INotificationHandle.progress` property.
+     */
+    readonly progress?: INotificationProgressProperties;
+}
+interface INotificationActions {
+    /**
+     * Primary actions show up as buttons as part of the message and will close
+     * the notification once clicked.
+     *
+     * Pass `ActionWithMenuAction` for an action that has additional menu actions.
+     */
+    readonly primary?: readonly IAction[];
+    /**
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     */
+    readonly secondary?: readonly IAction[];
+}
+interface INotificationProgressProperties {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
+    readonly infinite?: boolean;
+    /**
+     * Indicate the total amount of work.
+     */
+    readonly total?: number;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
+    readonly worked?: number;
+}
+interface INotificationProgress {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
+    infinite(): void;
+    /**
+     * Indicate the total amount of work.
+     */
+    total(value: number): void;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
+    worked(value: number): void;
+    /**
+     * Indicate that the long running operation is done.
+     */
+    done(): void;
+}
+interface INotificationHandle {
+    /**
+     * Will be fired once the notification is closed.
+     */
+    readonly onDidClose: Event<void>;
+    /**
+     * Will be fired whenever the visibility of the notification changes.
+     * A notification can either be visible as toast or inside the notification
+     * center if it is visible.
+     */
+    readonly onDidChangeVisibility: Event<boolean>;
+    /**
+     * Allows to indicate progress on the notification even after the
+     * notification is already visible.
+     */
+    readonly progress: INotificationProgress;
+    /**
+     * Allows to update the severity of the notification.
+     */
+    updateSeverity(severity: Severity): void;
+    /**
+     * Allows to update the message of the notification even after the
+     * notification is already visible.
+     */
+    updateMessage(message: NotificationMessage): void;
+    /**
+     * Allows to update the actions of the notification even after the
+     * notification is already visible.
+     */
+    updateActions(actions?: INotificationActions): void;
+    /**
+     * Hide the notification and remove it from the notification center.
+     */
+    close(): void;
+}
+interface IBasePromptChoice {
+    /**
+     * Label to show for the choice to the user.
+     */
+    readonly label: string;
+    /**
+     * Whether to keep the notification open after the choice was selected
+     * by the user. By default, will close the notification upon click.
+     */
+    readonly keepOpen?: boolean;
+    /**
+     * Triggered when the user selects the choice.
+     */
+    run: () => void;
+}
+interface IPromptChoice extends IBasePromptChoice {
+    /**
+     * Primary choices show up as buttons in the notification below the message.
+     * Secondary choices show up under the gear icon in the header of the notification.
+     */
+    readonly isSecondary?: boolean;
+}
+interface IPromptChoiceWithMenu extends IPromptChoice {
+    /**
+     * Additional choices those will be shown in the dropdown menu for this choice.
+     */
+    readonly menu: IBasePromptChoice[];
+    /**
+     * Menu is not supported on secondary choices
+     */
+    readonly isSecondary: false | undefined;
+}
+interface IPromptOptions extends INotificationProperties {
+    /**
+     * Will be called if the user closed the notification without picking
+     * any of the provided choices.
+     */
+    onCancel?: () => void;
+}
+interface IStatusMessageOptions {
+    /**
+     * An optional timeout after which the status message should show. By default
+     * the status message will show immediately.
+     */
+    readonly showAfter?: number;
+    /**
+     * An optional timeout after which the status message is to be hidden. By default
+     * the status message will not hide until another status message is displayed.
+     */
+    readonly hideAfter?: number;
+}
+declare enum NotificationsFilter {
+    /**
+     * No filter is enabled.
+     */
+    OFF = 0,
+    /**
+     * All notifications are configured as silent. See
+     * `INotificationProperties.silent` for more info.
+     */
+    SILENT = 1,
+    /**
+     * All notifications are silent except error notifications.
+    */
+    ERROR = 2
+}
+declare const INotificationService: ServiceIdentifier<INotificationService>;
+/**
+ * A service to bring up notifications and non-modal prompts.
+ *
+ * Note: use the `IDialogService` for a modal way to ask the user for input.
+ */
+interface INotificationService {
+    readonly _serviceBrand: undefined;
+    /**
+     * The DND mode can be enabled or disabled
+     * and will result in all info and warning
+     * notifications to be silent.
+     */
+    doNotDisturbMode: boolean;
+    /**
+     * Emitted when a new notification is added.
+     */
+    readonly onDidAddNotification: Event<INotification>;
+    /**
+     * Emitted when a notification is removed.
+     */
+    readonly onDidRemoveNotification: Event<INotification>;
+    /**
+     * Emitted when a do not disturb mode has changed.
+     */
+    readonly onDidChangeDoNotDisturbMode: Event<void>;
+    /**
+     * Show the provided notification to the user. The returned `INotificationHandle`
+     * can be used to control the notification afterwards.
+     *
+     * **Note:** If your intent is to show a message with actions to the user, consider
+     * the `INotificationService.prompt()` method instead which are optimized for
+     * this usecase and much easier to use!
+     *
+     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+     */
+    notify(notification: INotification): INotificationHandle;
+    /**
+     * A convenient way of reporting infos. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    info(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * A convenient way of reporting warnings. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    warn(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * A convenient way of reporting errors. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    error(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * Shows a prompt in the notification area with the provided choices. The prompt
+     * is non-modal. If you want to show a modal dialog instead, use `IDialogService`.
+     *
+     * @param severity the severity of the notification. Either `Info`, `Warning` or `Error`.
+     * @param message the message to show as status.
+     * @param choices options to be chosen from.
+     * @param options provides some optional configuration options.
+     *
+     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+     */
+    prompt(severity: Severity, message: string, choices: (IPromptChoice | IPromptChoiceWithMenu)[], options?: IPromptOptions): INotificationHandle;
+    /**
+     * Shows a status message in the status area with the provided text.
+     *
+     * @param message the message to show as status
+     * @param options provides some optional configuration options
+     *
+     * @returns a disposable to hide the status message
+     */
+    status(message: NotificationMessage, options?: IStatusMessageOptions): IDisposable;
+}
+declare class NoOpNotification implements INotificationHandle {
+    readonly progress: NoOpProgress;
+    readonly onDidClose: Event<any>;
+    readonly onDidChangeVisibility: Event<any>;
+    updateSeverity(severity: Severity): void;
+    updateMessage(message: NotificationMessage): void;
+    updateActions(actions?: INotificationActions): void;
+    close(): void;
+}
+declare class NoOpProgress implements INotificationProgress {
+    infinite(): void;
+    done(): void;
+    total(value: number): void;
+    worked(value: number): void;
+}
+
+interface IProgressIndicator {
+    /**
+     * Show progress customized with the provided flags.
+     */
+    show(infinite: true, delay?: number): IProgressRunner;
+    show(total: number, delay?: number): IProgressRunner;
+    /**
+     * Indicate progress for the duration of the provided promise. Progress will stop in
+     * any case of promise completion, error or cancellation.
+     */
+    showWhile(promise: Promise<unknown>, delay?: number): Promise<void>;
+}
+interface IProgressStep {
+    message?: string;
+    increment?: number;
+    total?: number;
+}
+interface IProgressRunner {
+    total(value: number): void;
+    worked(value: number): void;
+    done(): void;
+}
+interface IProgress<T> {
+    report(item: T): void;
+}
+
+interface IComposite {
+    /**
+     * An event when the composite gained focus.
+     */
+    readonly onDidFocus: Event<void>;
+    /**
+     * An event when the composite lost focus.
+     */
+    readonly onDidBlur: Event<void>;
+    /**
+     * Returns true if the composite has focus.
+     */
+    hasFocus(): boolean;
+    /**
+     * Returns the unique identifier of this composite.
+     */
+    getId(): string;
+    /**
+     * Returns the name of this composite to show in the title area.
+     */
+    getTitle(): string | undefined;
+    /**
+     * Returns the underlying control of this composite.
+     */
+    getControl(): ICompositeControl | undefined;
+    /**
+     * Asks the underlying control to focus.
+     */
+    focus(): void;
+}
+/**
+ * Marker interface for the composite control
+ */
+interface ICompositeControl {
+}
+
+type ColorIdentifier = string;
+declare const enum ColorTransformType {
+    Darken = 0,
+    Lighten = 1,
+    Transparent = 2,
+    Opaque = 3,
+    OneOf = 4,
+    LessProminent = 5,
+    IfDefinedThenElse = 6
+}
+type ColorTransform = {
+    op: ColorTransformType.Darken;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Lighten;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Transparent;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Opaque;
+    value: ColorValue;
+    background: ColorValue;
+} | {
+    op: ColorTransformType.OneOf;
+    values: readonly ColorValue[];
+} | {
+    op: ColorTransformType.LessProminent;
+    value: ColorValue;
+    background: ColorValue;
+    factor: number;
+    transparency: number;
+} | {
+    op: ColorTransformType.IfDefinedThenElse;
+    if: ColorIdentifier;
+    then: ColorValue;
+    else: ColorValue;
+};
+interface ColorDefaults {
+    light: ColorValue | null;
+    dark: ColorValue | null;
+    hcDark: ColorValue | null;
+    hcLight: ColorValue | null;
+}
+/**
+ * A Color Value is either a color literal, a reference to an other color or a derived color
+ */
+type ColorValue = Color | string | ColorIdentifier | ColorTransform;
+declare function registerColor(id: string, defaults: ColorDefaults | null, description: string, needsTransparency?: boolean, deprecationMessage?: string): ColorIdentifier;
+
+export { CommandsRegistry as A, registerColor as B, ColorIdentifier as C, IProgress as I, NotificationsFilter as N, SubmenuAction as S, IProgressStep as a, IProgressIndicator as b, IAction as c, ICommandService as d, INotificationService as e, NotificationMessage as f, NotificationPriority as g, INotificationProperties as h, NeverShowAgainScope as i, INeverShowAgainOptions as j, INotification as k, INotificationActions as l, INotificationProgress as m, INotificationProgressProperties as n, INotificationHandle as o, IPromptChoice as p, IPromptChoiceWithMenu as q, IPromptOptions as r, IStatusMessageOptions as s, NoOpNotification as t, NoOpProgress as u, IActionRunner as v, IComposite as w, Color as x, IRunEvent as y, ICompositeControl as z };