scratch-blocks 1.1.205 → 1.2.0-beta.1

package/blockly-rc/core/events/events_toolbox_item_select.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Events fired as a result of selecting an item on the toolbox.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.ToolboxItemSelect
+
+import * as registry from '../registry.js';
+import {AbstractEventJson} from './events_abstract.js';
+import {UiBase} from './events_ui_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a toolbox item has been selected.
+ */
+export class ToolboxItemSelect extends UiBase {
+  /** The previously selected toolbox item. */
+  oldItem?: string;
+
+  /** The newly selected toolbox item. */
+  newItem?: string;
+
+  override type = eventUtils.TOOLBOX_ITEM_SELECT;
+
+  /**
+   * @param opt_oldItem The previously selected toolbox item.
+   *     Undefined for a blank event.
+   * @param opt_newItem The newly selected toolbox item. Undefined for a blank
+   *     event.
+   * @param opt_workspaceId The workspace identifier for this event.
+   *    Undefined for a blank event.
+   */
+  constructor(
+    opt_oldItem?: string | null,
+    opt_newItem?: string | null,
+    opt_workspaceId?: string,
+  ) {
+    super(opt_workspaceId);
+    this.oldItem = opt_oldItem ?? undefined;
+    this.newItem = opt_newItem ?? undefined;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): ToolboxItemSelectJson {
+    const json = super.toJson() as ToolboxItemSelectJson;
+    json['oldItem'] = this.oldItem;
+    json['newItem'] = this.newItem;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of ToolboxItemSelect, but we can't specify that due to the fact that
+   *     parameters to static methods in subclasses must be supertypes of
+   *     parameters to static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: ToolboxItemSelectJson,
+    workspace: Workspace,
+    event?: any,
+  ): ToolboxItemSelect {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new ToolboxItemSelect(),
+    ) as ToolboxItemSelect;
+    newEvent.oldItem = json['oldItem'];
+    newEvent.newItem = json['newItem'];
+    return newEvent;
+  }
+}
+
+export interface ToolboxItemSelectJson extends AbstractEventJson {
+  oldItem?: string;
+  newItem?: string;
+}
+
+registry.register(
+  registry.Type.EVENT,
+  eventUtils.TOOLBOX_ITEM_SELECT,
+  ToolboxItemSelect,
+);

package/blockly-rc/core/events/events_trashcan_open.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Events fired as a result of trashcan flyout open and close.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.TrashcanOpen
+
+import * as registry from '../registry.js';
+import {AbstractEventJson} from './events_abstract.js';
+
+import {UiBase} from './events_ui_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners when the trashcan is opening or closing.
+ */
+export class TrashcanOpen extends UiBase {
+  /**
+   * True if the trashcan is currently opening (previously closed).
+   * False if it is currently closing (previously open).
+   */
+  isOpen?: boolean;
+  override type = eventUtils.TRASHCAN_OPEN;
+
+  /**
+   * @param opt_isOpen Whether the trashcan flyout is opening (false if
+   *     opening). Undefined for a blank event.
+   * @param opt_workspaceId The workspace identifier for this event.
+   *    Undefined for a blank event.
+   */
+  constructor(opt_isOpen?: boolean, opt_workspaceId?: string) {
+    super(opt_workspaceId);
+    this.isOpen = opt_isOpen;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): TrashcanOpenJson {
+    const json = super.toJson() as TrashcanOpenJson;
+    if (this.isOpen === undefined) {
+      throw new Error(
+        'Whether this is already open or not is undefined. Either pass ' +
+          'a value to the constructor, or call fromJson',
+      );
+    }
+    json['isOpen'] = this.isOpen;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of TrashcanOpen, but we can't specify that due to the fact that
+   *     parameters to static methods in subclasses must be supertypes of
+   *     parameters to static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: TrashcanOpenJson,
+    workspace: Workspace,
+    event?: any,
+  ): TrashcanOpen {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new TrashcanOpen(),
+    ) as TrashcanOpen;
+    newEvent.isOpen = json['isOpen'];
+    return newEvent;
+  }
+}
+
+export interface TrashcanOpenJson extends AbstractEventJson {
+  isOpen: boolean;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.TRASHCAN_OPEN, TrashcanOpen);

package/blockly-rc/core/events/events_ui_base.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Base class for events fired as a result of UI actions in
+ * Blockly's editor.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.UiBase
+
+import {Abstract as AbstractEvent} from './events_abstract.js';
+
+/**
+ * Base class for a UI event.
+ * UI events are events that don't need to be sent over the wire for multi-user
+ * editing to work (e.g. scrolling the workspace, zooming, opening toolbox
+ * categories).
+ * UI events do not undo or redo.
+ */
+export class UiBase extends AbstractEvent {
+  override isBlank = true;
+  override workspaceId: string;
+
+  // UI events do not undo or redo.
+  override recordUndo = false;
+
+  /** Whether or not the event is a UI event. */
+  override isUiEvent = true;
+
+  /**
+   * @param opt_workspaceId The workspace identifier for this event.
+   *    Undefined for a blank event.
+   */
+  constructor(opt_workspaceId?: string) {
+    super();
+
+    /** Whether or not the event is blank (to be populated by fromJson). */
+    this.isBlank = typeof opt_workspaceId === 'undefined';
+
+    /** The workspace identifier for this event. */
+    this.workspaceId = opt_workspaceId ? opt_workspaceId : '';
+  }
+}

package/blockly-rc/core/events/events_var_base.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Abstract class for a variable event.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.VarBase
+
+import type {
+  IVariableModel,
+  IVariableState,
+} from '../interfaces/i_variable_model.js';
+
+import {
+  Abstract as AbstractEvent,
+  AbstractEventJson,
+} from './events_abstract.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Abstract class for a variable event.
+ */
+export class VarBase extends AbstractEvent {
+  override isBlank = true;
+  /** The ID of the variable this event references. */
+  varId?: string;
+
+  /**
+   * @param opt_variable The variable this event corresponds to.  Undefined for
+   *     a blank event.
+   */
+  constructor(opt_variable?: IVariableModel<IVariableState>) {
+    super();
+    this.isBlank = typeof opt_variable === 'undefined';
+    if (!opt_variable) return;
+
+    this.varId = opt_variable.getId();
+    this.workspaceId = opt_variable.getWorkspace().id;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): VarBaseJson {
+    const json = super.toJson() as VarBaseJson;
+    if (!this.varId) {
+      throw new Error(
+        'The var ID is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['varId'] = this.varId;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of VarBase, but we can't specify that due to the fact that parameters
+   *     to static methods in subclasses must be supertypes of parameters to
+   *     static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: VarBaseJson,
+    workspace: Workspace,
+    event?: any,
+  ): VarBase {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new VarBase(),
+    ) as VarBase;
+    newEvent.varId = json['varId'];
+    return newEvent;
+  }
+}
+
+export interface VarBaseJson extends AbstractEventJson {
+  varId: string;
+}

package/blockly-rc/core/events/events_var_create.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Class for a variable creation event.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.VarCreate
+
+import * as registry from '../registry.js';
+import type {
+  IVariableModel,
+  IVariableState,
+} from '../interfaces/i_variable_model.js';
+
+import {VarBase, VarBaseJson} from './events_var_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a variable model has been created.
+ */
+export class VarCreate extends VarBase {
+  override type = eventUtils.VAR_CREATE;
+
+  /** The type of the variable that was created. */
+  varType?: string;
+
+  /** The name of the variable that was created. */
+  varName?: string;
+
+  /**
+   * @param opt_variable The created variable. Undefined for a blank event.
+   */
+  constructor(opt_variable?: IVariableModel<IVariableState>) {
+    super(opt_variable);
+
+    if (!opt_variable) {
+      return; // Blank event to be populated by fromJson.
+    }
+    this.varType = opt_variable.getType();
+    this.varName = opt_variable.getName();
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): VarCreateJson {
+    const json = super.toJson() as VarCreateJson;
+    if (this.varType === undefined) {
+      throw new Error(
+        'The var type is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.varName) {
+      throw new Error(
+        'The var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['varType'] = this.varType;
+    json['varName'] = this.varName;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of VarCreate, but we can't specify that due to the fact that parameters
+   *     to static methods in subclasses must be supertypes of parameters to
+   *     static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: VarCreateJson,
+    workspace: Workspace,
+    event?: any,
+  ): VarCreate {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new VarCreate(),
+    ) as VarCreate;
+    newEvent.varType = json['varType'];
+    newEvent.varName = json['varName'];
+    return newEvent;
+  }
+
+  /**
+   * Run a variable creation event.
+   *
+   * @param forward True if run forward, false if run backward (undo).
+   */
+  override run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    if (!this.varId) {
+      throw new Error(
+        'The var ID is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.varName) {
+      throw new Error(
+        'The var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (forward) {
+      workspace.createVariable(this.varName, this.varType, this.varId);
+    } else {
+      workspace.deleteVariableById(this.varId);
+    }
+  }
+}
+
+export interface VarCreateJson extends VarBaseJson {
+  varType: string;
+  varName: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.VAR_CREATE, VarCreate);

package/blockly-rc/core/events/events_var_delete.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.Events.VarDelete
+
+import * as registry from '../registry.js';
+import type {
+  IVariableModel,
+  IVariableState,
+} from '../interfaces/i_variable_model.js';
+
+import {VarBase, VarBaseJson} from './events_var_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a variable model has been deleted.
+ *
+ * @class
+ */
+export class VarDelete extends VarBase {
+  override type = eventUtils.VAR_DELETE;
+  /** The type of the variable that was deleted. */
+  varType?: string;
+  /** The name of the variable that was deleted. */
+  varName?: string;
+
+  /**
+   * @param opt_variable The deleted variable. Undefined for a blank event.
+   */
+  constructor(opt_variable?: IVariableModel<IVariableState>) {
+    super(opt_variable);
+
+    if (!opt_variable) {
+      return; // Blank event to be populated by fromJson.
+    }
+    this.varType = opt_variable.getType();
+    this.varName = opt_variable.getName();
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): VarDeleteJson {
+    const json = super.toJson() as VarDeleteJson;
+    if (this.varType === undefined) {
+      throw new Error(
+        'The var type is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.varName) {
+      throw new Error(
+        'The var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['varType'] = this.varType;
+    json['varName'] = this.varName;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of VarDelete, but we can't specify that due to the fact that parameters
+   *     to static methods in subclasses must be supertypes of parameters to
+   *     static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: VarDeleteJson,
+    workspace: Workspace,
+    event?: any,
+  ): VarDelete {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new VarDelete(),
+    ) as VarDelete;
+    newEvent.varType = json['varType'];
+    newEvent.varName = json['varName'];
+    return newEvent;
+  }
+
+  /**
+   * Run a variable deletion event.
+   *
+   * @param forward True if run forward, false if run backward (undo).
+   */
+  override run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    if (!this.varId) {
+      throw new Error(
+        'The var ID is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.varName) {
+      throw new Error(
+        'The var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (forward) {
+      workspace.deleteVariableById(this.varId);
+    } else {
+      workspace.createVariable(this.varName, this.varType, this.varId);
+    }
+  }
+}
+
+export interface VarDeleteJson extends VarBaseJson {
+  varType: string;
+  varName: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.VAR_DELETE, VarDelete);

package/blockly-rc/core/events/events_var_rename.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Former goog.module ID: Blockly.Events.VarRename
+
+import * as registry from '../registry.js';
+import type {
+  IVariableModel,
+  IVariableState,
+} from '../interfaces/i_variable_model.js';
+
+import {VarBase, VarBaseJson} from './events_var_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a variable model was renamed.
+ *
+ * @class
+ */
+export class VarRename extends VarBase {
+  override type = eventUtils.VAR_RENAME;
+
+  /** The previous name of the variable. */
+  oldName?: string;
+
+  /** The new name of the variable. */
+  newName?: string;
+
+  /**
+   * @param opt_variable The renamed variable. Undefined for a blank event.
+   * @param newName The new name the variable will be changed to.
+   */
+  constructor(opt_variable?: IVariableModel<IVariableState>, newName?: string) {
+    super(opt_variable);
+
+    if (!opt_variable) {
+      return; // Blank event to be populated by fromJson.
+    }
+    this.oldName = opt_variable.getName();
+    this.newName = typeof newName === 'undefined' ? '' : newName;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): VarRenameJson {
+    const json = super.toJson() as VarRenameJson;
+    if (!this.oldName) {
+      throw new Error(
+        'The old var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.newName) {
+      throw new Error(
+        'The new var name is undefined. Either pass a value to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['oldName'] = this.oldName;
+    json['newName'] = this.newName;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of VarRename, but we can't specify that due to the fact that parameters
+   *     to static methods in subclasses must be supertypes of parameters to
+   *     static methods in superclasses.
+   * @internal
+   */
+  static fromJson(
+    json: VarRenameJson,
+    workspace: Workspace,
+    event?: any,
+  ): VarRename {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new VarRename(),
+    ) as VarRename;
+    newEvent.oldName = json['oldName'];
+    newEvent.newName = json['newName'];
+    return newEvent;
+  }
+
+  /**
+   * Run a variable rename event.
+   *
+   * @param forward True if run forward, false if run backward (undo).
+   */
+  override run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    if (!this.varId) {
+      throw new Error(
+        'The var ID is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.oldName) {
+      throw new Error(
+        'The old var name is undefined. Either pass a variable to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.newName) {
+      throw new Error(
+        'The new var name is undefined. Either pass a value to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (forward) {
+      workspace.renameVariableById(this.varId, this.newName);
+    } else {
+      workspace.renameVariableById(this.varId, this.oldName);
+    }
+  }
+}
+
+export interface VarRenameJson extends VarBaseJson {
+  oldName: string;
+  newName: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.VAR_RENAME, VarRename);