Re-format the src/display/ files to enforce the ESLint no-var rule

This was done automatically, using `gulp lint --fix`.
This commit is contained in:
Jonas Jenwald 2020-10-02 13:51:21 +02:00
parent 2a8983d76b
commit e557be5a17
4 changed files with 489 additions and 489 deletions

View file

@ -15,7 +15,7 @@
import { FormatError, info, Util } from "../shared/util.js";
var ShadingIRs = {};
const ShadingIRs = {};
function applyBoundingBox(ctx, bbox) {
if (!bbox || typeof Path2D === "undefined") {
@ -30,26 +30,26 @@ function applyBoundingBox(ctx, bbox) {
ShadingIRs.RadialAxial = {
fromIR: function RadialAxial_fromIR(raw) {
var type = raw[1];
var bbox = raw[2];
var colorStops = raw[3];
var p0 = raw[4];
var p1 = raw[5];
var r0 = raw[6];
var r1 = raw[7];
const type = raw[1];
const bbox = raw[2];
const colorStops = raw[3];
const p0 = raw[4];
const p1 = raw[5];
const r0 = raw[6];
const r1 = raw[7];
return {
type: "Pattern",
getPattern: function RadialAxial_getPattern(ctx) {
applyBoundingBox(ctx, bbox);
var grad;
let grad;
if (type === "axial") {
grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
} else if (type === "radial") {
grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
}
for (var i = 0, ii = colorStops.length; i < ii; ++i) {
var c = colorStops[i];
for (let i = 0, ii = colorStops.length; i < ii; ++i) {
const c = colorStops[i];
grad.addColorStop(c[0], c[1]);
}
return grad;
@ -58,14 +58,14 @@ ShadingIRs.RadialAxial = {
},
};
var createMeshCanvas = (function createMeshCanvasClosure() {
const createMeshCanvas = (function createMeshCanvasClosure() {
function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
// Very basic Gouraud-shaded triangle rasterization algorithm.
var coords = context.coords,
const coords = context.coords,
colors = context.colors;
var bytes = data.data,
const bytes = data.data,
rowSize = data.width * 4;
var tmp;
let tmp;
if (coords[p1 + 1] > coords[p2 + 1]) {
tmp = p1;
p1 = p2;
@ -90,30 +90,30 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
c1 = c2;
c2 = tmp;
}
var x1 = (coords[p1] + context.offsetX) * context.scaleX;
var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
var x2 = (coords[p2] + context.offsetX) * context.scaleX;
var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
var x3 = (coords[p3] + context.offsetX) * context.scaleX;
var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
const x1 = (coords[p1] + context.offsetX) * context.scaleX;
const y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
const x2 = (coords[p2] + context.offsetX) * context.scaleX;
const y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
const x3 = (coords[p3] + context.offsetX) * context.scaleX;
const y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
if (y1 >= y3) {
return;
}
var c1r = colors[c1],
const c1r = colors[c1],
c1g = colors[c1 + 1],
c1b = colors[c1 + 2];
var c2r = colors[c2],
const c2r = colors[c2],
c2g = colors[c2 + 1],
c2b = colors[c2 + 2];
var c3r = colors[c3],
const c3r = colors[c3],
c3g = colors[c3 + 1],
c3b = colors[c3 + 2];
var minY = Math.round(y1),
const minY = Math.round(y1),
maxY = Math.round(y3);
var xa, car, cag, cab;
var xb, cbr, cbg, cbb;
for (var y = minY; y <= maxY; y++) {
let xa, car, cag, cab;
let xb, cbr, cbg, cbb;
for (let y = minY; y <= maxY; y++) {
if (y < y2) {
let k;
if (y < y1) {
@ -154,10 +154,10 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
cbr = c1r - (c1r - c3r) * k;
cbg = c1g - (c1g - c3g) * k;
cbb = c1b - (c1b - c3b) * k;
var x1_ = Math.round(Math.min(xa, xb));
var x2_ = Math.round(Math.max(xa, xb));
var j = rowSize * y + x1_ * 4;
for (var x = x1_; x <= x2_; x++) {
const x1_ = Math.round(Math.min(xa, xb));
const x2_ = Math.round(Math.max(xa, xb));
let j = rowSize * y + x1_ * 4;
for (let x = x1_; x <= x2_; x++) {
k = (xa - x) / (xa - xb);
if (k < 0) {
k = 0;
@ -173,17 +173,17 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
}
function drawFigure(data, figure, context) {
var ps = figure.coords;
var cs = figure.colors;
var i, ii;
const ps = figure.coords;
const cs = figure.colors;
let i, ii;
switch (figure.type) {
case "lattice":
var verticesPerRow = figure.verticesPerRow;
var rows = Math.floor(ps.length / verticesPerRow) - 1;
var cols = verticesPerRow - 1;
for (i = 0; i < rows; i++) {
var q = i * verticesPerRow;
for (var j = 0; j < cols; j++, q++) {
let q = i * verticesPerRow;
for (let j = 0; j < cols; j++, q++) {
drawTriangle(
data,
context,
@ -239,30 +239,30 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
) {
// we will increase scale on some weird factor to let antialiasing take
// care of "rough" edges
var EXPECTED_SCALE = 1.1;
const EXPECTED_SCALE = 1.1;
// MAX_PATTERN_SIZE is used to avoid OOM situation.
var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough
const MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough
// We need to keep transparent border around our pattern for fill():
// createPattern with 'no-repeat' will bleed edges across entire area.
var BORDER_SIZE = 2;
const BORDER_SIZE = 2;
var offsetX = Math.floor(bounds[0]);
var offsetY = Math.floor(bounds[1]);
var boundsWidth = Math.ceil(bounds[2]) - offsetX;
var boundsHeight = Math.ceil(bounds[3]) - offsetY;
const offsetX = Math.floor(bounds[0]);
const offsetY = Math.floor(bounds[1]);
const boundsWidth = Math.ceil(bounds[2]) - offsetX;
const boundsHeight = Math.ceil(bounds[3]) - offsetY;
var width = Math.min(
const width = Math.min(
Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)),
MAX_PATTERN_SIZE
);
var height = Math.min(
const height = Math.min(
Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)),
MAX_PATTERN_SIZE
);
var scaleX = boundsWidth / width;
var scaleY = boundsHeight / height;
const scaleX = boundsWidth / width;
const scaleY = boundsHeight / height;
var context = {
const context = {
coords,
colors,
offsetX: -offsetX,
@ -271,10 +271,10 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
scaleY: 1 / scaleY,
};
var paddedWidth = width + BORDER_SIZE * 2;
var paddedHeight = height + BORDER_SIZE * 2;
const paddedWidth = width + BORDER_SIZE * 2;
const paddedHeight = height + BORDER_SIZE * 2;
var canvas, tmpCanvas, i, ii;
let canvas, tmpCanvas, i, ii;
if (webGLContext.isEnabled) {
canvas = webGLContext.drawFigures({
width,
@ -299,11 +299,11 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
paddedHeight,
false
);
var tmpCtx = tmpCanvas.context;
const tmpCtx = tmpCanvas.context;
var data = tmpCtx.createImageData(width, height);
const data = tmpCtx.createImageData(width, height);
if (backgroundColor) {
var bytes = data.data;
const bytes = data.data;
for (i = 0, ii = bytes.length; i < ii; i += 4) {
bytes[i] = backgroundColor[0];
bytes[i + 1] = backgroundColor[1];
@ -332,32 +332,32 @@ var createMeshCanvas = (function createMeshCanvasClosure() {
ShadingIRs.Mesh = {
fromIR: function Mesh_fromIR(raw) {
// var type = raw[1];
var coords = raw[2];
var colors = raw[3];
var figures = raw[4];
var bounds = raw[5];
var matrix = raw[6];
var bbox = raw[7];
var background = raw[8];
const coords = raw[2];
const colors = raw[3];
const figures = raw[4];
const bounds = raw[5];
const matrix = raw[6];
const bbox = raw[7];
const background = raw[8];
return {
type: "Pattern",
getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
applyBoundingBox(ctx, bbox);
var scale;
let scale;
if (shadingFill) {
scale = Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
} else {
// Obtain scale from matrix and current transformation matrix.
scale = Util.singularValueDecompose2dScale(owner.baseTransform);
if (matrix) {
var matrixScale = Util.singularValueDecompose2dScale(matrix);
const matrixScale = Util.singularValueDecompose2dScale(matrix);
scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
}
}
// Rasterizing on the main thread since sending/queue large canvases
// might cause OOM.
var temporaryPatternCanvas = createMeshCanvas(
const temporaryPatternCanvas = createMeshCanvas(
bounds,
scale,
coords,
@ -399,7 +399,7 @@ ShadingIRs.Dummy = {
};
function getShadingPatternFromIR(raw) {
var shadingIR = ShadingIRs[raw[0]];
const shadingIR = ShadingIRs[raw[0]];
if (!shadingIR) {
throw new Error(`Unknown IR type: ${raw[0]}`);
}
@ -409,13 +409,13 @@ function getShadingPatternFromIR(raw) {
/**
* @type {any}
*/
var TilingPattern = (function TilingPatternClosure() {
var PaintType = {
const TilingPattern = (function TilingPatternClosure() {
const PaintType = {
COLORED: 1,
UNCOLORED: 2,
};
var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough
const MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough
// eslint-disable-next-line no-shadow
function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
@ -435,14 +435,14 @@ var TilingPattern = (function TilingPatternClosure() {
TilingPattern.prototype = {
createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
var operatorList = this.operatorList;
var bbox = this.bbox;
var xstep = this.xstep;
var ystep = this.ystep;
var paintType = this.paintType;
var tilingType = this.tilingType;
var color = this.color;
var canvasGraphicsFactory = this.canvasGraphicsFactory;
const operatorList = this.operatorList;
const bbox = this.bbox;
const xstep = this.xstep;
const ystep = this.ystep;
const paintType = this.paintType;
const tilingType = this.tilingType;
const color = this.color;
const canvasGraphicsFactory = this.canvasGraphicsFactory;
info("TilingType: " + tilingType);
@ -466,17 +466,17 @@ var TilingPattern = (function TilingPatternClosure() {
// TODO: Fix the implementation, to allow this scenario to be painted
// correctly.
var x0 = bbox[0],
const x0 = bbox[0],
y0 = bbox[1],
x1 = bbox[2],
y1 = bbox[3];
// Obtain scale from matrix and current transformation matrix.
var matrixScale = Util.singularValueDecompose2dScale(this.matrix);
var curMatrixScale = Util.singularValueDecompose2dScale(
const matrixScale = Util.singularValueDecompose2dScale(this.matrix);
const curMatrixScale = Util.singularValueDecompose2dScale(
this.baseTransform
);
var combinedScale = [
const combinedScale = [
matrixScale[0] * curMatrixScale[0],
matrixScale[1] * curMatrixScale[1],
];
@ -484,25 +484,25 @@ var TilingPattern = (function TilingPatternClosure() {
// Use width and height values that are as close as possible to the end
// result when the pattern is used. Too low value makes the pattern look
// blurry. Too large value makes it look too crispy.
var dimx = this.getSizeAndScale(
const dimx = this.getSizeAndScale(
xstep,
this.ctx.canvas.width,
combinedScale[0]
);
var dimy = this.getSizeAndScale(
const dimy = this.getSizeAndScale(
ystep,
this.ctx.canvas.height,
combinedScale[1]
);
var tmpCanvas = owner.cachedCanvases.getCanvas(
const tmpCanvas = owner.cachedCanvases.getCanvas(
"pattern",
dimx.size,
dimy.size,
true
);
var tmpCtx = tmpCanvas.context;
var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
const tmpCtx = tmpCanvas.context;
const graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
graphics.groupLevel = owner.groupLevel;
this.setFillAndStrokeStyleToContext(graphics, paintType, color);
@ -535,8 +535,8 @@ var TilingPattern = (function TilingPatternClosure() {
// Use the destination canvas's size if it is bigger than the hard-coded
// limit of MAX_PATTERN_SIZE to avoid clipping patterns that cover the
// whole canvas.
var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
var size = Math.ceil(step * scale);
const maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
let size = Math.ceil(step * scale);
if (size >= maxSize) {
size = maxSize;
} else {
@ -547,8 +547,8 @@ var TilingPattern = (function TilingPatternClosure() {
clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
if (Array.isArray(bbox) && bbox.length === 4) {
var bboxWidth = x1 - x0;
var bboxHeight = y1 - y0;
const bboxWidth = x1 - x0;
const bboxHeight = y1 - y0;
graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
graphics.clip();
graphics.endPath();
@ -589,7 +589,7 @@ var TilingPattern = (function TilingPatternClosure() {
ctx.setTransform.apply(ctx, this.baseTransform);
ctx.transform.apply(ctx, this.matrix);
var temporaryPatternCanvas = this.createPatternCanvas(owner);
const temporaryPatternCanvas = this.createPatternCanvas(owner);
return ctx.createPattern(temporaryPatternCanvas, "repeat");
},