scratch-blocks 1.1.206 → 2.0.0-beta.1

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

@@ -0,0 +1,207 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Class for comment move event.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.CommentMove
+
+import * as registry from '../registry.js';
+import {Coordinate} from '../utils/coordinate.js';
+import type {WorkspaceComment} from '../comments/workspace_comment.js';
+
+import {CommentBase, CommentBaseJson} from './events_comment_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a workspace comment has moved.
+ */
+export class CommentMove extends CommentBase {
+  override type = eventUtils.COMMENT_MOVE;
+
+  /** The comment that is being moved. */
+  comment_?: WorkspaceComment;
+
+  // TODO(#6774): We should remove underscores.
+  /** The location of the comment before the move, in workspace coordinates. */
+  oldCoordinate_?: Coordinate;
+
+  /** The location of the comment after the move, in workspace coordinates. */
+  newCoordinate_?: Coordinate;
+
+  /**
+   * An explanation of what this move is for.  Known values include:
+   *  'drag' -- A drag operation completed.
+   *  'snap' -- Comment got shifted to line up with the grid.
+   *  'inbounds' -- Block got pushed back into a non-scrolling workspace.
+   *  'create' -- Block created via deserialization.
+   *  'cleanup' -- Workspace aligned top-level blocks.
+   * Event merging may create multiple reasons: ['drag', 'inbounds', 'snap'].
+   */
+  reason?: string[];
+
+  /**
+   * @param opt_comment The comment that is being moved.  Undefined for a blank
+   *     event.
+   */
+  constructor(opt_comment?: WorkspaceComment) {
+    super(opt_comment);
+
+    if (!opt_comment) {
+      return; // Blank event to be populated by fromJson.
+    }
+
+    this.comment_ = opt_comment;
+    this.oldCoordinate_ = opt_comment.getRelativeToSurfaceXY();
+  }
+
+  /**
+   * Record the comment's new location.  Called after the move.  Can only be
+   * called once.
+   */
+  recordNew() {
+    if (this.newCoordinate_) {
+      throw Error(
+        'Tried to record the new position of a comment on the ' +
+          'same event twice.',
+      );
+    }
+    if (!this.comment_) {
+      throw new Error(
+        'The comment is undefined. Pass a comment to ' +
+          'the constructor if you want to use the record functionality',
+      );
+    }
+    this.newCoordinate_ = this.comment_.getRelativeToSurfaceXY();
+  }
+
+  /**
+   * Sets the reason for a move event.
+   *
+   * @param reason Why is this move happening?  'drag', 'bump', 'snap', ...
+   */
+  setReason(reason: string[]) {
+    this.reason = reason;
+  }
+
+  /**
+   * Override the location before the move.  Use this if you don't create the
+   * event until the end of the move, but you know the original location.
+   *
+   * @param xy The location before the move, in workspace coordinates.
+   */
+  setOldCoordinate(xy: Coordinate) {
+    this.oldCoordinate_ = xy;
+  }
+
+  // TODO (#1266): "Full" and "minimal" serialization.
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): CommentMoveJson {
+    const json = super.toJson() as CommentMoveJson;
+    if (!this.oldCoordinate_) {
+      throw new Error(
+        'The old comment position is undefined. Either pass a comment to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.newCoordinate_) {
+      throw new Error(
+        'The new comment position is undefined. Either call recordNew, or ' +
+          'call fromJson',
+      );
+    }
+    json['oldCoordinate'] =
+      `${Math.round(this.oldCoordinate_.x)}, ` +
+      `${Math.round(this.oldCoordinate_.y)}`;
+    json['newCoordinate'] =
+      Math.round(this.newCoordinate_.x) +
+      ',' +
+      Math.round(this.newCoordinate_.y);
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of CommentMove, 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: CommentMoveJson,
+    workspace: Workspace,
+    event?: any,
+  ): CommentMove {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new CommentMove(),
+    ) as CommentMove;
+    let xy = json['oldCoordinate'].split(',');
+    newEvent.oldCoordinate_ = new Coordinate(Number(xy[0]), Number(xy[1]));
+    xy = json['newCoordinate'].split(',');
+    newEvent.newCoordinate_ = new Coordinate(Number(xy[0]), Number(xy[1]));
+    return newEvent;
+  }
+
+  /**
+   * Does this event record any change of state?
+   *
+   * @returns False if something changed.
+   */
+  override isNull(): boolean {
+    return Coordinate.equals(this.oldCoordinate_, this.newCoordinate_);
+  }
+
+  /**
+   * Run a move event.
+   *
+   * @param forward True if run forward, false if run backward (undo).
+   */
+  override run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    if (!this.commentId) {
+      throw new Error(
+        'The comment ID is undefined. Either pass a comment to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    // TODO: Remove cast when we update getCommentById.
+    const comment = workspace.getCommentById(
+      this.commentId,
+    ) as unknown as WorkspaceComment;
+    if (!comment) {
+      console.warn("Can't move non-existent comment: " + this.commentId);
+      return;
+    }
+
+    const target = forward ? this.newCoordinate_ : this.oldCoordinate_;
+    if (!target) {
+      throw new Error(
+        'Either oldCoordinate_ or newCoordinate_ is undefined. ' +
+          'Either pass a comment to the constructor and call recordNew, ' +
+          'or call fromJson',
+      );
+    }
+    comment.moveTo(target);
+  }
+}
+
+export interface CommentMoveJson extends CommentBaseJson {
+  oldCoordinate: string;
+  newCoordinate: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.COMMENT_MOVE, CommentMove);

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

@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Class for comment resize event.
+ */
+
+import * as registry from '../registry.js';
+import {Size} from '../utils/size.js';
+import type {WorkspaceComment} from '../comments/workspace_comment.js';
+
+import {CommentBase, CommentBaseJson} from './events_comment_base.js';
+import * as eventUtils from './utils.js';
+import type {Workspace} from '../workspace.js';
+
+/**
+ * Notifies listeners that a workspace comment has resized.
+ */
+export class CommentResize extends CommentBase {
+  override type = eventUtils.COMMENT_RESIZE;
+
+  /** The size of the comment before the resize. */
+  oldSize?: Size;
+
+  /** The size of the comment after the resize. */
+  newSize?: Size;
+
+  /**
+   * @param opt_comment The comment that is being resized. Undefined for a blank
+   *     event.
+   */
+  constructor(opt_comment?: WorkspaceComment) {
+    super(opt_comment);
+
+    if (!opt_comment) {
+      return; // Blank event to be populated by fromJson.
+    }
+
+    this.oldSize = opt_comment.getSize();
+  }
+
+  /**
+   * Record the comment's new size. Called after the resize. Can only be
+   * called once.
+   */
+  recordCurrentSizeAsNewSize() {
+    if (this.newSize) {
+      throw Error(
+        'Tried to record the new size of a comment on the ' +
+          'same event twice.',
+      );
+    }
+    const workspace = this.getEventWorkspace_();
+    if (!this.commentId) {
+      throw new Error(
+        'The comment ID is undefined. Either pass a comment to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    const comment = workspace.getCommentById(this.commentId);
+    if (!comment) {
+      throw new Error(
+        'The comment associated with the comment resize event ' +
+          'could not be found',
+      );
+    }
+    this.newSize = comment.getSize();
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): CommentResizeJson {
+    const json = super.toJson() as CommentResizeJson;
+    if (!this.oldSize) {
+      throw new Error(
+        'The old comment size is undefined. Either pass a comment to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    if (!this.newSize) {
+      throw new Error(
+        'The new comment size is undefined. Either call ' +
+          'recordCurrentSizeAsNewSize, or call fromJson',
+      );
+    }
+    json['oldWidth'] = Math.round(this.oldSize.width);
+    json['oldHeight'] = Math.round(this.oldSize.height);
+    json['newWidth'] = Math.round(this.newSize.width);
+    json['newHeight'] = Math.round(this.newSize.height);
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of CommentResize, 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: CommentResizeJson,
+    workspace: Workspace,
+    event?: any,
+  ): CommentResize {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new CommentResize(),
+    ) as CommentResize;
+    newEvent.oldSize = new Size(json['oldWidth'], json['oldHeight']);
+    newEvent.newSize = new Size(json['newWidth'], json['newHeight']);
+    return newEvent;
+  }
+
+  /**
+   * Does this event record any change of state?
+   *
+   * @returns False if something changed.
+   */
+  override isNull(): boolean {
+    return Size.equals(this.oldSize, this.newSize);
+  }
+
+  /**
+   * Run a resize event.
+   *
+   * @param forward True if run forward, false if run backward (undo).
+   */
+  override run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    if (!this.commentId) {
+      throw new Error(
+        'The comment ID is undefined. Either pass a comment to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    const comment = workspace.getCommentById(this.commentId);
+    if (!comment) {
+      console.warn("Can't resize non-existent comment: " + this.commentId);
+      return;
+    }
+
+    const size = forward ? this.newSize : this.oldSize;
+    if (!size) {
+      throw new Error(
+        'Either oldSize or newSize is undefined. ' +
+          'Either pass a comment to the constructor and call ' +
+          'recordCurrentSizeAsNewSize, or call fromJson',
+      );
+    }
+    comment.setSize(size);
+  }
+}
+
+export interface CommentResizeJson extends CommentBaseJson {
+  oldWidth: number;
+  oldHeight: number;
+  newWidth: number;
+  newHeight: number;
+}
+
+registry.register(
+  registry.Type.EVENT,
+  eventUtils.COMMENT_RESIZE,
+  CommentResize,
+);

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

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Events fired as a result of a marker move.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.MarkerMove
+
+import type {Block} from '../block.js';
+import {ASTNode} from '../keyboard_nav/ast_node.js';
+import * as registry from '../registry.js';
+import type {Workspace} from '../workspace.js';
+import {AbstractEventJson} from './events_abstract.js';
+
+import {UiBase} from './events_ui_base.js';
+import * as eventUtils from './utils.js';
+
+/**
+ * Notifies listeners that a marker (used for keyboard navigation) has
+ * moved.
+ */
+export class MarkerMove extends UiBase {
+  /** The ID of the block the marker is now on, if any. */
+  blockId?: string;
+
+  /** The old node the marker used to be on, if any. */
+  oldNode?: ASTNode;
+
+  /** The new node the marker is now on. */
+  newNode?: ASTNode;
+
+  /**
+   * True if this is a cursor event, false otherwise.
+   * For information about cursors vs markers see {@link
+   * https://blocklycodelabs.dev/codelabs/keyboard-navigation/index.html?index=..%2F..index#1}.
+   */
+  isCursor?: boolean;
+
+  override type = eventUtils.MARKER_MOVE;
+
+  /**
+   * @param opt_block The affected block. Null if current node is of type
+   *     workspace. Undefined for a blank event.
+   * @param isCursor Whether this is a cursor event. Undefined for a blank
+   *     event.
+   * @param opt_oldNode The old node the marker used to be on.
+   *    Undefined for a blank event.
+   * @param opt_newNode The new node the marker is now on.
+   *    Undefined for a blank event.
+   */
+  constructor(
+    opt_block?: Block | null,
+    isCursor?: boolean,
+    opt_oldNode?: ASTNode | null,
+    opt_newNode?: ASTNode,
+  ) {
+    let workspaceId = opt_block ? opt_block.workspace.id : undefined;
+    if (opt_newNode && opt_newNode.getType() === ASTNode.types.WORKSPACE) {
+      workspaceId = (opt_newNode.getLocation() as Workspace).id;
+    }
+    super(workspaceId);
+
+    this.blockId = opt_block?.id;
+    this.oldNode = opt_oldNode || undefined;
+    this.newNode = opt_newNode;
+    this.isCursor = isCursor;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): MarkerMoveJson {
+    const json = super.toJson() as MarkerMoveJson;
+    if (this.isCursor === undefined) {
+      throw new Error(
+        'Whether this is a cursor event or not is undefined. Either pass ' +
+          'a value to the constructor, or call fromJson',
+      );
+    }
+    if (!this.newNode) {
+      throw new Error(
+        'The new node is undefined. Either pass a node to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['isCursor'] = this.isCursor;
+    json['blockId'] = this.blockId;
+    json['oldNode'] = this.oldNode;
+    json['newNode'] = this.newNode;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of MarkerMove, 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: MarkerMoveJson,
+    workspace: Workspace,
+    event?: any,
+  ): MarkerMove {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new MarkerMove(),
+    ) as MarkerMove;
+    newEvent.isCursor = json['isCursor'];
+    newEvent.blockId = json['blockId'];
+    newEvent.oldNode = json['oldNode'];
+    newEvent.newNode = json['newNode'];
+    return newEvent;
+  }
+}
+
+export interface MarkerMoveJson extends AbstractEventJson {
+  isCursor: boolean;
+  blockId?: string;
+  oldNode?: ASTNode;
+  newNode: ASTNode;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.MARKER_MOVE, MarkerMove);

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

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Events fired as a result of element select action.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.Selected
+
+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';
+
+/**
+ * Class for a selected event.
+ * Notifies listeners that a new element has been selected.
+ */
+export class Selected extends UiBase {
+  /** The id of the last selected selectable element. */
+  oldElementId?: string;
+
+  /**
+   * The id of the newly selected selectable element,
+   * or undefined if unselected.
+   */
+  newElementId?: string;
+
+  override type = eventUtils.SELECTED;
+
+  /**
+   * @param opt_oldElementId The ID of the previously selected element. Null if
+   *     no element last selected. Undefined for a blank event.
+   * @param opt_newElementId The ID of the selected element. Null if no element
+   *     currently selected (deselect). Undefined for a blank event.
+   * @param opt_workspaceId The workspace identifier for this event.
+   *    Null if no element previously selected. Undefined for a blank event.
+   */
+  constructor(
+    opt_oldElementId?: string | null,
+    opt_newElementId?: string | null,
+    opt_workspaceId?: string,
+  ) {
+    super(opt_workspaceId);
+
+    this.oldElementId = opt_oldElementId ?? undefined;
+    this.newElementId = opt_newElementId ?? undefined;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): SelectedJson {
+    const json = super.toJson() as SelectedJson;
+    json['oldElementId'] = this.oldElementId;
+    json['newElementId'] = this.newElementId;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of Selected, 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: SelectedJson,
+    workspace: Workspace,
+    event?: any,
+  ): Selected {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new Selected(),
+    ) as Selected;
+    newEvent.oldElementId = json['oldElementId'];
+    newEvent.newElementId = json['newElementId'];
+    return newEvent;
+  }
+}
+
+export interface SelectedJson extends AbstractEventJson {
+  oldElementId?: string;
+  newElementId?: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.SELECTED, Selected);

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

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Events fired as a result of a theme update.
+ *
+ * @class
+ */
+// Former goog.module ID: Blockly.Events.ThemeChange
+
+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 the workspace theme has changed.
+ */
+export class ThemeChange extends UiBase {
+  /** The name of the new theme that has been set. */
+  themeName?: string;
+
+  override type = eventUtils.THEME_CHANGE;
+
+  /**
+   * @param opt_themeName The theme name. Undefined for a blank event.
+   * @param opt_workspaceId The workspace identifier for this event.
+   *    event. Undefined for a blank event.
+   */
+  constructor(opt_themeName?: string, opt_workspaceId?: string) {
+    super(opt_workspaceId);
+    this.themeName = opt_themeName;
+  }
+
+  /**
+   * Encode the event as JSON.
+   *
+   * @returns JSON representation.
+   */
+  override toJson(): ThemeChangeJson {
+    const json = super.toJson() as ThemeChangeJson;
+    if (!this.themeName) {
+      throw new Error(
+        'The theme name is undefined. Either pass a theme name to ' +
+          'the constructor, or call fromJson',
+      );
+    }
+    json['themeName'] = this.themeName;
+    return json;
+  }
+
+  /**
+   * Deserializes the JSON event.
+   *
+   * @param event The event to append new properties to. Should be a subclass
+   *     of ThemeChange, 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: ThemeChangeJson,
+    workspace: Workspace,
+    event?: any,
+  ): ThemeChange {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new ThemeChange(),
+    ) as ThemeChange;
+    newEvent.themeName = json['themeName'];
+    return newEvent;
+  }
+}
+
+export interface ThemeChangeJson extends AbstractEventJson {
+  themeName: string;
+}
+
+registry.register(registry.Type.EVENT, eventUtils.THEME_CHANGE, ThemeChange);