完成世界书、骰子、apiconfig页面处理

frontend/node_modules/roughjs/bin/fillers/dashed-filler.js

@@ -0,0 +1,36 @@
+import { lineLength } from '../geometry';
+import { polygonHachureLines } from './scan-line-hachure';
+export class DashedFiller {
+    constructor(helper) {
+        this.helper = helper;
+    }
+    fillPolygons(polygonList, o) {
+        const lines = polygonHachureLines(polygonList, o);
+        return { type: 'fillSketch', ops: this.dashedLine(lines, o) };
+    }
+    dashedLine(lines, o) {
+        const offset = o.dashOffset < 0 ? (o.hachureGap < 0 ? (o.strokeWidth * 4) : o.hachureGap) : o.dashOffset;
+        const gap = o.dashGap < 0 ? (o.hachureGap < 0 ? (o.strokeWidth * 4) : o.hachureGap) : o.dashGap;
+        const ops = [];
+        lines.forEach((line) => {
+            const length = lineLength(line);
+            const count = Math.floor(length / (offset + gap));
+            const startOffset = (length + gap - (count * (offset + gap))) / 2;
+            let p1 = line[0];
+            let p2 = line[1];
+            if (p1[0] > p2[0]) {
+                p1 = line[1];
+                p2 = line[0];
+            }
+            const alpha = Math.atan((p2[1] - p1[1]) / (p2[0] - p1[0]));
+            for (let i = 0; i < count; i++) {
+                const lstart = i * (offset + gap);
+                const lend = lstart + offset;
+                const start = [p1[0] + (lstart * Math.cos(alpha)) + (startOffset * Math.cos(alpha)), p1[1] + lstart * Math.sin(alpha) + (startOffset * Math.sin(alpha))];
+                const end = [p1[0] + (lend * Math.cos(alpha)) + (startOffset * Math.cos(alpha)), p1[1] + (lend * Math.sin(alpha)) + (startOffset * Math.sin(alpha))];
+                ops.push(...this.helper.doubleLineOps(start[0], start[1], end[0], end[1], o));
+            }
+        });
+        return ops;
+    }
+}

frontend/node_modules/roughjs/bin/fillers/filler-interface.d.ts

@@ -0,0 +1,11 @@
+import { ResolvedOptions, OpSet, Op } from '../core';
+import { Point } from '../geometry';
+export interface PatternFiller {
+    fillPolygons(polygonList: Point[][], o: ResolvedOptions): OpSet;
+}
+export interface RenderHelper {
+    randOffset(x: number, o: ResolvedOptions): number;
+    randOffsetWithRange(min: number, max: number, o: ResolvedOptions): number;
+    ellipse(x: number, y: number, width: number, height: number, o: ResolvedOptions): OpSet;
+    doubleLineOps(x1: number, y1: number, x2: number, y2: number, o: ResolvedOptions): Op[];
+}

frontend/node_modules/roughjs/bin/fillers/hachure-filler.d.ts

@@ -0,0 +1,10 @@
+import { PatternFiller, RenderHelper } from './filler-interface';
+import { ResolvedOptions, OpSet, Op } from '../core';
+import { Point, Line } from '../geometry';
+export declare class HachureFiller implements PatternFiller {
+    private helper;
+    constructor(helper: RenderHelper);
+    fillPolygons(polygonList: Point[][], o: ResolvedOptions): OpSet;
+    protected _fillPolygons(polygonList: Point[][], o: ResolvedOptions): OpSet;
+    protected renderLines(lines: Line[], o: ResolvedOptions): Op[];
+}

frontend/node_modules/roughjs/bin/fillers/hatch-filler.js

@@ -0,0 +1,10 @@
+import { HachureFiller } from './hachure-filler';
+export class HatchFiller extends HachureFiller {
+    fillPolygons(polygonList, o) {
+        const set = this._fillPolygons(polygonList, o);
+        const o2 = Object.assign({}, o, { hachureAngle: o.hachureAngle + 90 });
+        const set2 = this._fillPolygons(polygonList, o2);
+        set.ops = set.ops.concat(set2.ops);
+        return set;
+    }
+}

frontend/node_modules/roughjs/bin/fillers/scan-line-hachure.js

@@ -0,0 +1,17 @@
+import { hachureLines } from 'hachure-fill';
+export function polygonHachureLines(polygonList, o) {
+    var _a;
+    const angle = o.hachureAngle + 90;
+    let gap = o.hachureGap;
+    if (gap < 0) {
+        gap = o.strokeWidth * 4;
+    }
+    gap = Math.round(Math.max(gap, 0.1));
+    let skipOffset = 1;
+    if (o.roughness >= 1) {
+        if ((((_a = o.randomizer) === null || _a === void 0 ? void 0 : _a.next()) || Math.random()) > 0.7) {
+            skipOffset = gap;
+        }
+    }
+    return hachureLines(polygonList, gap, angle, skipOffset || 1);
+}

frontend/node_modules/roughjs/bin/fillers/zigzag-filler.d.ts

@@ -0,0 +1,6 @@
+import { HachureFiller } from './hachure-filler';
+import { ResolvedOptions, OpSet } from '../core';
+import { Point } from '../geometry';
+export declare class ZigZagFiller extends HachureFiller {
+    fillPolygons(polygonList: Point[][], o: ResolvedOptions): OpSet;
+}

frontend/node_modules/roughjs/bin/fillers/zigzag-filler.js

@@ -0,0 +1,31 @@
+import { HachureFiller } from './hachure-filler';
+import { polygonHachureLines } from './scan-line-hachure';
+import { lineLength } from '../geometry';
+export class ZigZagFiller extends HachureFiller {
+    fillPolygons(polygonList, o) {
+        let gap = o.hachureGap;
+        if (gap < 0) {
+            gap = o.strokeWidth * 4;
+        }
+        gap = Math.max(gap, 0.1);
+        const o2 = Object.assign({}, o, { hachureGap: gap });
+        const lines = polygonHachureLines(polygonList, o2);
+        const zigZagAngle = (Math.PI / 180) * o.hachureAngle;
+        const zigzagLines = [];
+        const dgx = gap * 0.5 * Math.cos(zigZagAngle);
+        const dgy = gap * 0.5 * Math.sin(zigZagAngle);
+        for (const [p1, p2] of lines) {
+            if (lineLength([p1, p2])) {
+                zigzagLines.push([
+                    [p1[0] - dgx, p1[1] + dgy],
+                    [...p2],
+                ], [
+                    [p1[0] + dgx, p1[1] - dgy],
+                    [...p2],
+                ]);
+            }
+        }
+        const ops = this.renderLines(zigzagLines, o);
+        return { type: 'fillSketch', ops };
+    }
+}