mirror of
https://github.com/google/blockly.git
synced 2026-01-04 15:40:08 +01:00
ce22f42868
* chore(deps): Add pretter-plugin-organize-imports * chore: Remove insignificant blank lines in import sections Since prettier-plugin-organize-imports sorts imports within sections separated by blank lines, but preserves the section divisions, remove any blank lines that are not dividing imports into meaningful sections. Do not remove blank lines separating side-effect-only imports from main imports. * chore: Remove unneded eslint-disable directives * chore: Organise imports
347 lines
11 KiB
TypeScript
347 lines
11 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2012 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @file JavaScript code generator class, including helper methods for
|
|
* generating JavaScript for blocks.
|
|
*/
|
|
|
|
// Former goog.module ID: Blockly.JavaScript
|
|
|
|
import type {Block} from '../../core/block.js';
|
|
import {CodeGenerator} from '../../core/generator.js';
|
|
import {inputTypes} from '../../core/inputs/input_types.js';
|
|
import {Names, NameType} from '../../core/names.js';
|
|
import * as stringUtils from '../../core/utils/string.js';
|
|
import * as Variables from '../../core/variables.js';
|
|
import type {Workspace} from '../../core/workspace.js';
|
|
|
|
/**
|
|
* Order of operation ENUMs.
|
|
* https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
|
|
*/
|
|
// prettier-ignore
|
|
export enum Order {
|
|
ATOMIC = 0, // 0 "" ...
|
|
NEW = 1.1, // new
|
|
MEMBER = 1.2, // . []
|
|
FUNCTION_CALL = 2, // ()
|
|
INCREMENT = 3, // ++
|
|
DECREMENT = 3, // --
|
|
BITWISE_NOT = 4.1, // ~
|
|
UNARY_PLUS = 4.2, // +
|
|
UNARY_NEGATION = 4.3, // -
|
|
LOGICAL_NOT = 4.4, // !
|
|
TYPEOF = 4.5, // typeof
|
|
VOID = 4.6, // void
|
|
DELETE = 4.7, // delete
|
|
AWAIT = 4.8, // await
|
|
EXPONENTIATION = 5.0, // **
|
|
MULTIPLICATION = 5.1, // *
|
|
DIVISION = 5.2, // /
|
|
MODULUS = 5.3, // %
|
|
SUBTRACTION = 6.1, // -
|
|
ADDITION = 6.2, // +
|
|
BITWISE_SHIFT = 7, // << >> >>>
|
|
RELATIONAL = 8, // < <= > >=
|
|
IN = 8, // in
|
|
INSTANCEOF = 8, // instanceof
|
|
EQUALITY = 9, // == != === !==
|
|
BITWISE_AND = 10, // &
|
|
BITWISE_XOR = 11, // ^
|
|
BITWISE_OR = 12, // |
|
|
LOGICAL_AND = 13, // &&
|
|
LOGICAL_OR = 14, // ||
|
|
CONDITIONAL = 15, // ?:
|
|
ASSIGNMENT = 16, // = += -= **= *= /= %= <<= >>= ...
|
|
YIELD = 17, // yield
|
|
COMMA = 18, // ,
|
|
NONE = 99, // (...)
|
|
}
|
|
|
|
/**
|
|
* JavaScript code generator class.
|
|
*/
|
|
export class JavascriptGenerator extends CodeGenerator {
|
|
/** List of outer-inner pairings that do NOT require parentheses. */
|
|
ORDER_OVERRIDES: [Order, Order][] = [
|
|
// (foo()).bar -> foo().bar
|
|
// (foo())[0] -> foo()[0]
|
|
[Order.FUNCTION_CALL, Order.MEMBER],
|
|
// (foo())() -> foo()()
|
|
[Order.FUNCTION_CALL, Order.FUNCTION_CALL],
|
|
// (foo.bar).baz -> foo.bar.baz
|
|
// (foo.bar)[0] -> foo.bar[0]
|
|
// (foo[0]).bar -> foo[0].bar
|
|
// (foo[0])[1] -> foo[0][1]
|
|
[Order.MEMBER, Order.MEMBER],
|
|
// (foo.bar)() -> foo.bar()
|
|
// (foo[0])() -> foo[0]()
|
|
[Order.MEMBER, Order.FUNCTION_CALL],
|
|
|
|
// !(!foo) -> !!foo
|
|
[Order.LOGICAL_NOT, Order.LOGICAL_NOT],
|
|
// a * (b * c) -> a * b * c
|
|
[Order.MULTIPLICATION, Order.MULTIPLICATION],
|
|
// a + (b + c) -> a + b + c
|
|
[Order.ADDITION, Order.ADDITION],
|
|
// a && (b && c) -> a && b && c
|
|
[Order.LOGICAL_AND, Order.LOGICAL_AND],
|
|
// a || (b || c) -> a || b || c
|
|
[Order.LOGICAL_OR, Order.LOGICAL_OR],
|
|
];
|
|
|
|
/** @param name Name of the language the generator is for. */
|
|
constructor(name = 'JavaScript') {
|
|
super(name);
|
|
this.isInitialized = false;
|
|
|
|
// Copy Order values onto instance for backwards compatibility
|
|
// while ensuring they are not part of the publically-advertised
|
|
// API.
|
|
//
|
|
// TODO(#7085): deprecate these in due course. (Could initially
|
|
// replace data properties with get accessors that call
|
|
// deprecate.warn().)
|
|
for (const key in Order) {
|
|
// Must assign Order[key] to a temporary to get the type guard to work;
|
|
// see https://github.com/microsoft/TypeScript/issues/10530.
|
|
const value = Order[key];
|
|
// Skip reverse-lookup entries in the enum. Due to
|
|
// https://github.com/microsoft/TypeScript/issues/55713 this (as
|
|
// of TypeScript 5.5.2) actually narrows the type of value to
|
|
// never - but that still allows the following assignment to
|
|
// succeed.
|
|
if (typeof value === 'string') continue;
|
|
(this as unknown as Record<string, Order>)['ORDER_' + key] = value;
|
|
}
|
|
|
|
// List of illegal variable names. This is not intended to be a
|
|
// security feature. Blockly is 100% client-side, so bypassing
|
|
// this list is trivial. This is intended to prevent users from
|
|
// accidentally clobbering a built-in object or function.
|
|
//
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
|
|
this.addReservedWords(
|
|
'break,case,catch,class,const,continue,debugger,default,delete,do,' +
|
|
'else,export,extends,finally,for,function,if,import,in,instanceof,' +
|
|
'new,return,super,switch,this,throw,try,typeof,var,void,' +
|
|
'while,with,yield,' +
|
|
'enum,' +
|
|
'implements,interface,let,package,private,protected,public,static,' +
|
|
'await,' +
|
|
'null,true,false,' +
|
|
// Magic variable.
|
|
'arguments,' +
|
|
// Everything in the current environment (835 items in Chrome,
|
|
// 104 in Node).
|
|
Object.getOwnPropertyNames(globalThis).join(','),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialise the database of variable names.
|
|
*
|
|
* @param workspace Workspace to generate code from.
|
|
*/
|
|
init(workspace: Workspace) {
|
|
super.init(workspace);
|
|
|
|
if (!this.nameDB_) {
|
|
this.nameDB_ = new Names(this.RESERVED_WORDS_);
|
|
} else {
|
|
this.nameDB_.reset();
|
|
}
|
|
|
|
this.nameDB_.setVariableMap(workspace.getVariableMap());
|
|
this.nameDB_.populateVariables(workspace);
|
|
this.nameDB_.populateProcedures(workspace);
|
|
|
|
const defvars = [];
|
|
// Add developer variables (not created or named by the user).
|
|
const devVarList = Variables.allDeveloperVariables(workspace);
|
|
for (let i = 0; i < devVarList.length; i++) {
|
|
defvars.push(
|
|
this.nameDB_.getName(devVarList[i], NameType.DEVELOPER_VARIABLE),
|
|
);
|
|
}
|
|
|
|
// Add user variables, but only ones that are being used.
|
|
const variables = Variables.allUsedVarModels(workspace);
|
|
for (let i = 0; i < variables.length; i++) {
|
|
defvars.push(
|
|
this.nameDB_.getName(variables[i].getId(), NameType.VARIABLE),
|
|
);
|
|
}
|
|
|
|
// Declare all of the variables.
|
|
if (defvars.length) {
|
|
this.definitions_['variables'] = 'var ' + defvars.join(', ') + ';';
|
|
}
|
|
this.isInitialized = true;
|
|
}
|
|
|
|
/**
|
|
* Prepend the generated code with the variable definitions.
|
|
*
|
|
* @param code Generated code.
|
|
* @returns Completed code.
|
|
*/
|
|
finish(code: string): string {
|
|
// Convert the definitions dictionary into a list.
|
|
const definitions = Object.values(this.definitions_);
|
|
// Call Blockly.CodeGenerator's finish.
|
|
super.finish(code);
|
|
this.isInitialized = false;
|
|
|
|
this.nameDB_!.reset();
|
|
return definitions.join('\n\n') + '\n\n\n' + code;
|
|
}
|
|
|
|
/**
|
|
* Naked values are top-level blocks with outputs that aren't plugged into
|
|
* anything. A trailing semicolon is needed to make this legal.
|
|
*
|
|
* @param line Line of generated code.
|
|
* @returns Legal line of code.
|
|
*/
|
|
scrubNakedValue(line: string): string {
|
|
return line + ';\n';
|
|
}
|
|
|
|
/**
|
|
* Encode a string as a properly escaped JavaScript string, complete with
|
|
* quotes.
|
|
*
|
|
* @param string Text to encode.
|
|
* @returns JavaScript string.
|
|
*/
|
|
quote_(string: string): string {
|
|
// Can't use goog.string.quote since Google's style guide recommends
|
|
// JS string literals use single quotes.
|
|
string = string
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/\n/g, '\\\n')
|
|
.replace(/'/g, "\\'");
|
|
return "'" + string + "'";
|
|
}
|
|
|
|
/**
|
|
* Encode a string as a properly escaped multiline JavaScript string, complete
|
|
* with quotes.
|
|
* @param string Text to encode.
|
|
* @returns JavaScript string.
|
|
*/
|
|
multiline_quote_(string: string): string {
|
|
// Can't use goog.string.quote since Google's style guide recommends
|
|
// JS string literals use single quotes.
|
|
const lines = string.split(/\n/g).map(this.quote_);
|
|
return lines.join(" + '\\n' +\n");
|
|
}
|
|
|
|
/**
|
|
* Common tasks for generating JavaScript from blocks.
|
|
* Handles comments for the specified block and any connected value blocks.
|
|
* Calls any statements following this block.
|
|
*
|
|
* @param block The current block.
|
|
* @param code The JavaScript code created for this block.
|
|
* @param thisOnly True to generate code for only this statement.
|
|
* @returns JavaScript code with comments and subsequent blocks added.
|
|
*/
|
|
scrub_(block: Block, code: string, thisOnly = false): string {
|
|
let commentCode = '';
|
|
// Only collect comments for blocks that aren't inline.
|
|
if (!block.outputConnection || !block.outputConnection.targetConnection) {
|
|
// Collect comment for this block.
|
|
let comment = block.getCommentText();
|
|
if (comment) {
|
|
comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
|
|
commentCode += this.prefixLines(comment + '\n', '// ');
|
|
}
|
|
// Collect comments for all value arguments.
|
|
// Don't collect comments for nested statements.
|
|
for (let i = 0; i < block.inputList.length; i++) {
|
|
if (block.inputList[i].type === inputTypes.VALUE) {
|
|
const childBlock = block.inputList[i].connection!.targetBlock();
|
|
if (childBlock) {
|
|
comment = this.allNestedComments(childBlock);
|
|
if (comment) {
|
|
commentCode += this.prefixLines(comment, '// ');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const nextBlock =
|
|
block.nextConnection && block.nextConnection.targetBlock();
|
|
const nextCode = thisOnly ? '' : this.blockToCode(nextBlock);
|
|
return commentCode + code + nextCode;
|
|
}
|
|
|
|
/**
|
|
* Generate code representing the specified value input, adjusted to take into
|
|
* account indexing (zero- or one-based) and optionally by a specified delta
|
|
* and/or by negation.
|
|
*
|
|
* @param block The block.
|
|
* @param atId The ID of the input block to get (and adjust) the value of.
|
|
* @param delta Value to add.
|
|
* @param negate Whether to negate the value.
|
|
* @param order The highest order acting on this value.
|
|
* @returns The adjusted value or code that evaluates to it.
|
|
*/
|
|
getAdjusted(
|
|
block: Block,
|
|
atId: string,
|
|
delta = 0,
|
|
negate = false,
|
|
order = Order.NONE,
|
|
): string {
|
|
if (block.workspace.options.oneBasedIndex) {
|
|
delta--;
|
|
}
|
|
const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
|
|
|
|
let orderForInput = order;
|
|
if (delta > 0) {
|
|
orderForInput = Order.ADDITION;
|
|
} else if (delta < 0) {
|
|
orderForInput = Order.SUBTRACTION;
|
|
} else if (negate) {
|
|
orderForInput = Order.UNARY_NEGATION;
|
|
}
|
|
|
|
let at = this.valueToCode(block, atId, orderForInput) || defaultAtIndex;
|
|
|
|
// Easy case: no adjustments.
|
|
if (delta === 0 && !negate) {
|
|
return at;
|
|
}
|
|
// If the index is a naked number, adjust it right now.
|
|
if (stringUtils.isNumber(at)) {
|
|
at = String(Number(at) + delta);
|
|
if (negate) {
|
|
at = String(-Number(at));
|
|
}
|
|
return at;
|
|
}
|
|
// If the index is dynamic, adjust it in code.
|
|
if (delta > 0) {
|
|
at = `${at} + ${delta}`;
|
|
} else if (delta < 0) {
|
|
at = `${at} - ${-delta}`;
|
|
}
|
|
if (negate) {
|
|
at = delta ? `-(${at})` : `-${at}`;
|
|
}
|
|
if (Math.floor(order) >= Math.floor(orderForInput)) {
|
|
at = `(${at})`;
|
|
}
|
|
return at;
|
|
}
|
|
}
|