blockly 9.0.0-beta.0 → 9.0.0-beta.1

package/core/serialization/exceptions.ts

@@ -1,98 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Contains custom errors thrown by the serialization system.
- */
-
-/**
- * Contains custom errors thrown by the serialization system.
- * @namespace Blockly.serialization.exceptions
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.serialization.exceptions');
-
-import type {Block} from '../block.js';
-import type {State} from './blocks.js';
-
-
-/** @alias Blockly.serialization.exceptions.DeserializationError */
-export class DeserializationError extends Error {}
-
-/**
- * Represents an error where the serialized state is expected to provide a
- * block type, but it is not provided.
- * @alias Blockly.serialization.exceptions.MissingBlockType
- */
-export class MissingBlockType extends DeserializationError {
-  /**
-   * @param state The state object which is missing the block type.
-   * @internal
-   */
-  constructor(public state: State) {
-    super(`Expected to find a 'type' property, defining the block type`);
-  }
-}
-
-/**
- * Represents an error where deserialization encountered a block that did
- * not have a connection that was defined in the serialized state.
- * @alias Blockly.serialization.exceptions.MissingConnection
- */
-export class MissingConnection extends DeserializationError {
-  /**
-   * @param connection The name of the connection that is missing. E.g.
-   *     'IF0', or 'next'.
-   * @param block The block missing the connection.
-   * @param state The state object containing the bad connection.
-   * @internal
-   */
-  constructor(connection: string, public block: Block, public state: State) {
-    super(`The block ${block.toDevString()} is missing a(n) ${connection}
-connection`);
-  }
-}
-
-/**
- * Represents an error where deserialization tried to connect two connections
- * that were not compatible.
- * @alias Blockly.serialization.exceptions.BadConnectionCheck
- */
-export class BadConnectionCheck extends DeserializationError {
-  /**
-   * @param reason The reason the connections were not compatible.
-   * @param childConnection The name of the incompatible child connection. E.g.
-   *     'output' or 'previous'.
-   * @param childBlock The child block that could not connect to its parent.
-   * @param childState The state object representing the child block.
-   * @internal
-   */
-  constructor(
-      reason: string, childConnection: string, public childBlock: Block,
-      public childState: State) {
-    super(`The block ${childBlock.toDevString()} could not connect its
-${childConnection} to its parent, because: ${reason}`);
-  }
-}
-
-/**
- * Represents an error where deserialization encountered a real block as it
- * was deserializing children of a shadow.
- * This is an error because it is an invariant of Blockly that shadow blocks
- * do not have real children.
- * @alias Blockly.serialization.exceptions.RealChildOfShadow
- */
-export class RealChildOfShadow extends DeserializationError {
-  /**
-   * @param state The state object representing the real block.
-   * @internal
-   */
-  constructor(public state: State) {
-    super(`Encountered a real block which is defined as a child of a shadow
-block. It is an invariant of Blockly that shadow blocks only have shadow
-children`);
-  }
-}

package/core/serialization/priorities.ts

@@ -1,32 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview The top level namespace for priorities of plugin serializers.
- * Includes constants for the priorities of different plugin
- * serializers. Higher priorities are deserialized first.
- */
-
-/**
- * The top level namespace for priorities of plugin serializers.
- * Includes constants for the priorities of different plugin serializers. Higher
- * priorities are deserialized first.
- * @namespace Blockly.serialization.priorities
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.serialization.priorities');
-
-
-/**
- * The priority for deserializing variables.
- * @alias Blockly.serialization.priorities.VARIABLES
- */
-export const VARIABLES = 100;
-/**
- * The priority for deserializing blocks.
- * @alias Blockly.serialization.priorities.BLOCKS
- */
-export const BLOCKS = 50;

package/core/serialization/registry.ts

@@ -1,43 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Contains functions registering serializers (eg blocks,
- * variables, plugins, etc).
- */
-
-/**
- * Contains functions registering serializers (eg blocks, variables, plugins,
- * etc).
- * @namespace Blockly.serialization.registry
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.serialization.registry');
-
-// eslint-disable-next-line no-unused-vars
-import type {ISerializer} from '../interfaces/i_serializer.js';
-import * as registry from '../registry.js';
-
-
-/**
- * Registers the given serializer so that it can be used for serialization and
- * deserialization.
- * @param name The name of the serializer to register.
- * @param serializer The serializer to register.
- * @alias Blockly.serialization.registry.register
- */
-export function register(name: string, serializer: ISerializer) {
-  registry.register(registry.Type.SERIALIZER, name, serializer);
-}
-
-/**
- * Unregisters the serializer associated with the given name.
- * @param name The name of the serializer to unregister.
- * @alias Blockly.serialization.registry.unregister
- */
-export function unregister(name: string) {
-  registry.unregister(registry.Type.SERIALIZER, name);
-}

package/core/serialization/variables.ts

@@ -1,96 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Handles serializing variables to plain JavaScript objects, only
- * containing state.
- */
-
-/**
- * Handles serializing variables to plain JavaScript objects, only containing
- * state.
- * @namespace Blockly.serialization.variables
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.serialization.variables');
-
-import type {ISerializer} from '../interfaces/i_serializer.js';
-import type {Workspace} from '../workspace.js';
-
-import * as priorities from './priorities.js';
-import * as serializationRegistry from './registry.js';
-
-
-/**
- * Represents the state of a given variable.
- * @alias Blockly.serialization.variables.State
- */
-export interface State {
-  name: string;
-  id: string;
-  type: string|undefined;
-}
-
-/**
- * Serializer for saving and loading variable state.
- * @alias Blockly.serialization.variables.VariableSerializer
- */
-class VariableSerializer implements ISerializer {
-  priority: number;
-
-  /* eslint-disable-next-line require-jsdoc */
-  constructor() {
-    /** The priority for deserializing variables. */
-    this.priority = priorities.VARIABLES;
-  }
-
-  /**
-   * Serializes the variables of the given workspace.
-   * @param workspace The workspace to save the variables of.
-   * @return The state of the workspace's variables, or null if there are no
-   *     variables.
-   */
-  save(workspace: Workspace): State[]|null {
-    const variableStates = [];
-    for (const variable of workspace.getAllVariables()) {
-      const state = {
-        'name': variable.name,
-        'id': variable.getId(),
-      };
-      if (variable.type) {
-        (state as AnyDuringMigration)['type'] = variable.type;
-      }
-      variableStates.push(state);
-    }
-    // AnyDuringMigration because:  Type '{ name: string; id: string; }[] |
-    // null' is not assignable to type 'State[] | null'.
-    return (variableStates.length ? variableStates : null) as
-        AnyDuringMigration;
-  }
-
-  /**
-   * Deserializes the variable defined by the given state into the given
-   * workspace.
-   * @param state The state of the variables to deserialize.
-   * @param workspace The workspace to deserialize into.
-   */
-  load(state: State[], workspace: Workspace) {
-    for (const varState of state) {
-      workspace.createVariable(
-          varState['name'], varState['type'], varState['id']);
-    }
-  }
-
-  /**
-   * Disposes of any variables that exist on the workspace.
-   * @param workspace The workspace to clear the variables of.
-   */
-  clear(workspace: Workspace) {
-    workspace.getVariableMap().clear();
-  }
-}
-
-serializationRegistry.register('variables', new VariableSerializer());

package/core/serialization/workspaces.ts

@@ -1,106 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Contains top-level functions for serializing workspaces to
- * plain JavaScript objects.
- */
-
-/**
- * Contains top-level functions for serializing workspaces to plain JavaScript
- * objects.
- * @namespace Blockly.serialization.workspaces
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.serialization.workspaces');
-
-import * as eventUtils from '../events/utils.js';
-import type {ISerializer} from '../interfaces/i_serializer.js';
-import * as registry from '../registry.js';
-import * as dom from '../utils/dom.js';
-// eslint-disable-next-line no-unused-vars
-import type {Workspace} from '../workspace.js';
-import {WorkspaceSvg} from '../workspace_svg.js';
-
-
-/**
- * Returns the state of the workspace as a plain JavaScript object.
- * @param workspace The workspace to serialize.
- * @return The serialized state of the workspace.
- * @alias Blockly.serialization.workspaces.save
- */
-export function save(workspace: Workspace):
-    {[key: string]: AnyDuringMigration} {
-  const state = Object.create(null);
-  const serializerMap = registry.getAllItems(registry.Type.SERIALIZER, true);
-  for (const key in serializerMap) {
-    const save = (serializerMap[key] as ISerializer)?.save(workspace);
-    if (save) {
-      state[key] = save;
-    }
-  }
-  return state;
-}
-
-/**
- * Loads the variable represented by the given state into the given workspace.
- * @param state The state of the workspace to deserialize into the workspace.
- * @param workspace The workspace to add the new state to.
- * @param param1 recordUndo: If true, events triggered by this function will be
- *     undo-able by the user. False by default.
- * @alias Blockly.serialization.workspaces.load
- */
-export function load(
-    state: {[key: string]: AnyDuringMigration}, workspace: Workspace,
-    {recordUndo = false}: {recordUndo?: boolean} = {}) {
-  const serializerMap = registry.getAllItems(registry.Type.SERIALIZER, true);
-  if (!serializerMap) {
-    return;
-  }
-
-  const deserializers = Object.entries(serializerMap)
-                            .sort(
-                                (a, b) => (b[1] as ISerializer)!.priority -
-                                    (a[1] as ISerializer)!.priority);
-
-  const prevRecordUndo = eventUtils.getRecordUndo();
-  eventUtils.setRecordUndo(recordUndo);
-  const existingGroup = eventUtils.getGroup();
-  if (!existingGroup) {
-    eventUtils.setGroup(true);
-  }
-
-  dom.startTextWidthCache();
-  if (workspace instanceof WorkspaceSvg) {
-    workspace.setResizesEnabled(false);
-  }
-
-  // We want to trigger clearing in reverse priority order so plugins don't end
-  // up missing dependencies.
-  for (const [, deserializer] of deserializers.reverse()) {
-    (deserializer as ISerializer)?.clear(workspace);
-  }
-
-  // reverse() is destructive, so we have to re-reverse to correct the order.
-  for (let [name, deserializer] of deserializers.reverse()) {
-    name = name;
-    const pluginState = state[name];
-    if (pluginState) {
-      (deserializer as ISerializer)?.load(state[name], workspace);
-    }
-  }
-
-  if (workspace instanceof WorkspaceSvg) {
-    workspace.setResizesEnabled(true);
-  }
-  dom.stopTextWidthCache();
-
-  eventUtils.fire(new (eventUtils.get(eventUtils.FINISHED_LOADING))!
-                  (workspace));
-
-  eventUtils.setGroup(existingGroup);
-  eventUtils.setRecordUndo(prevRecordUndo);
-}

package/core/shortcut_items.ts

@@ -1,266 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Registers default keyboard shortcuts.
- */
-
-/**
- * Registers default keyboard shortcuts.
- * @namespace Blockly.ShortcutItems
- */
-import * as goog from '../closure/goog/goog.js';
-goog.declareModuleId('Blockly.ShortcutItems');
-
-import {BlockSvg} from './block_svg.js';
-import * as clipboard from './clipboard.js';
-import * as common from './common.js';
-import {Gesture} from './gesture.js';
-import type {ICopyable} from './interfaces/i_copyable.js';
-import {KeyboardShortcut, ShortcutRegistry} from './shortcut_registry.js';
-import {KeyCodes} from './utils/keycodes.js';
-import type {WorkspaceSvg} from './workspace_svg.js';
-
-
-/**
- * Object holding the names of the default shortcut items.
- * @alias Blockly.ShortcutItems.names
- */
-export enum names {
-  ESCAPE = 'escape',
-  DELETE = 'delete',
-  COPY = 'copy',
-  CUT = 'cut',
-  PASTE = 'paste',
-  UNDO = 'undo',
-  REDO = 'redo'
-}
-
-/**
- * Keyboard shortcut to hide chaff on escape.
- * @alias Blockly.ShortcutItems.registerEscape
- */
-export function registerEscape() {
-  const escapeAction: KeyboardShortcut = {
-    name: names.ESCAPE,
-    preconditionFn(workspace) {
-      return !workspace.options.readOnly;
-    },
-    callback(workspace) {
-      // AnyDuringMigration because:  Property 'hideChaff' does not exist on
-      // type 'Workspace'.
-      (workspace as AnyDuringMigration).hideChaff();
-      return true;
-    },
-    keyCodes: [KeyCodes.ESC],
-  };
-  ShortcutRegistry.registry.register(escapeAction);
-}
-
-/**
- * Keyboard shortcut to delete a block on delete or backspace
- * @alias Blockly.ShortcutItems.registerDelete
- */
-export function registerDelete() {
-  const deleteShortcut: KeyboardShortcut = {
-    name: names.DELETE,
-    preconditionFn(workspace) {
-      const selected = common.getSelected();
-      return !workspace.options.readOnly && selected != null &&
-          selected.isDeletable();
-    },
-    callback(workspace, e) {
-      // Delete or backspace.
-      // Stop the browser from going back to the previous page.
-      // Do this first to prevent an error in the delete code from resulting in
-      // data loss.
-      e.preventDefault();
-      // Don't delete while dragging.  Jeez.
-      if (Gesture.inProgress()) {
-        return false;
-      }
-      (common.getSelected() as BlockSvg).checkAndDelete();
-      return true;
-    },
-    keyCodes: [KeyCodes.DELETE, KeyCodes.BACKSPACE],
-  };
-  ShortcutRegistry.registry.register(deleteShortcut);
-}
-
-/**
- * Keyboard shortcut to copy a block on ctrl+c, cmd+c, or alt+c.
- * @alias Blockly.ShortcutItems.registerCopy
- */
-export function registerCopy() {
-  const ctrlC = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.C, [KeyCodes.CTRL]);
-  const altC =
-      ShortcutRegistry.registry.createSerializedKey(KeyCodes.C, [KeyCodes.ALT]);
-  const metaC = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.C, [KeyCodes.META]);
-
-  const copyShortcut: KeyboardShortcut = {
-    name: names.COPY,
-    preconditionFn(workspace) {
-      const selected = common.getSelected();
-      return !workspace.options.readOnly && !Gesture.inProgress() &&
-          selected != null && selected.isDeletable() && selected.isMovable();
-    },
-    callback(workspace, e) {
-      // Prevent the default copy behavior, which may beep or otherwise indicate
-      // an error due to the lack of a selection.
-      e.preventDefault();
-      // AnyDuringMigration because:  Property 'hideChaff' does not exist on
-      // type 'Workspace'.
-      (workspace as AnyDuringMigration).hideChaff();
-      clipboard.copy(common.getSelected() as ICopyable);
-      return true;
-    },
-    keyCodes: [ctrlC, altC, metaC],
-  };
-  ShortcutRegistry.registry.register(copyShortcut);
-}
-
-/**
- * Keyboard shortcut to copy and delete a block on ctrl+x, cmd+x, or alt+x.
- * @alias Blockly.ShortcutItems.registerCut
- */
-export function registerCut() {
-  const ctrlX = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.X, [KeyCodes.CTRL]);
-  const altX =
-      ShortcutRegistry.registry.createSerializedKey(KeyCodes.X, [KeyCodes.ALT]);
-  const metaX = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.X, [KeyCodes.META]);
-
-  const cutShortcut: KeyboardShortcut = {
-    name: names.CUT,
-    preconditionFn(workspace) {
-      const selected = common.getSelected();
-      return !workspace.options.readOnly && !Gesture.inProgress() &&
-          selected != null && selected instanceof BlockSvg &&
-          selected.isDeletable() && selected.isMovable() &&
-          !selected.workspace!.isFlyout;
-    },
-    callback() {
-      const selected = common.getSelected();
-      if (!selected) {
-        // Shouldn't happen but appeases the type system
-        return false;
-      }
-      clipboard.copy(selected);
-      (selected as BlockSvg).checkAndDelete();
-      return true;
-    },
-    keyCodes: [ctrlX, altX, metaX],
-  };
-
-  ShortcutRegistry.registry.register(cutShortcut);
-}
-
-/**
- * Keyboard shortcut to paste a block on ctrl+v, cmd+v, or alt+v.
- * @alias Blockly.ShortcutItems.registerPaste
- */
-export function registerPaste() {
-  const ctrlV = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.V, [KeyCodes.CTRL]);
-  const altV =
-      ShortcutRegistry.registry.createSerializedKey(KeyCodes.V, [KeyCodes.ALT]);
-  const metaV = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.V, [KeyCodes.META]);
-
-  const pasteShortcut: KeyboardShortcut = {
-    name: names.PASTE,
-    preconditionFn(workspace) {
-      return !workspace.options.readOnly && !Gesture.inProgress();
-    },
-    callback() {
-      return !!(clipboard.paste());
-    },
-    keyCodes: [ctrlV, altV, metaV],
-  };
-
-  ShortcutRegistry.registry.register(pasteShortcut);
-}
-
-/**
- * Keyboard shortcut to undo the previous action on ctrl+z, cmd+z, or alt+z.
- * @alias Blockly.ShortcutItems.registerUndo
- */
-export function registerUndo() {
-  const ctrlZ = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Z, [KeyCodes.CTRL]);
-  const altZ =
-      ShortcutRegistry.registry.createSerializedKey(KeyCodes.Z, [KeyCodes.ALT]);
-  const metaZ = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Z, [KeyCodes.META]);
-
-  const undoShortcut: KeyboardShortcut = {
-    name: names.UNDO,
-    preconditionFn(workspace) {
-      return !workspace.options.readOnly && !Gesture.inProgress();
-    },
-    callback(workspace) {
-      // 'z' for undo 'Z' is for redo.
-      (workspace as WorkspaceSvg).hideChaff();
-      workspace.undo(false);
-      return true;
-    },
-    keyCodes: [ctrlZ, altZ, metaZ],
-  };
-  ShortcutRegistry.registry.register(undoShortcut);
-}
-
-/**
- * Keyboard shortcut to redo the previous action on ctrl+shift+z, cmd+shift+z,
- * or alt+shift+z.
- * @alias Blockly.ShortcutItems.registerRedo
- */
-export function registerRedo() {
-  const ctrlShiftZ = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Z, [KeyCodes.SHIFT, KeyCodes.CTRL]);
-  const altShiftZ = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Z, [KeyCodes.SHIFT, KeyCodes.ALT]);
-  const metaShiftZ = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Z, [KeyCodes.SHIFT, KeyCodes.META]);
-  // Ctrl-y is redo in Windows.  Command-y is never valid on Macs.
-  const ctrlY = ShortcutRegistry.registry.createSerializedKey(
-      KeyCodes.Y, [KeyCodes.CTRL]);
-
-  const redoShortcut: KeyboardShortcut = {
-    name: names.REDO,
-    preconditionFn(workspace) {
-      return !Gesture.inProgress() && !workspace.options.readOnly;
-    },
-    callback(workspace) {
-      // 'z' for undo 'Z' is for redo.
-      (workspace as WorkspaceSvg).hideChaff();
-      workspace.undo(true);
-      return true;
-    },
-    keyCodes: [ctrlShiftZ, altShiftZ, metaShiftZ, ctrlY],
-  };
-  ShortcutRegistry.registry.register(redoShortcut);
-}
-
-/**
- * Registers all default keyboard shortcut item. This should be called once per
- * instance of KeyboardShortcutRegistry.
- * @alias Blockly.ShortcutItems.registerDefaultShortcuts
- * @internal
- */
-export function registerDefaultShortcuts() {
-  registerEscape();
-  registerDelete();
-  registerCopy();
-  registerCut();
-  registerPaste();
-  registerUndo();
-  registerRedo();
-}
-
-registerDefaultShortcuts();