ranuts 0.4.1-alpha.2 → 0.5.1

package/dist/src/utils/visual/event/boundary.d.ts

@@ -1,5 +1,5 @@
-import type { Container } from '@/utils/visual/vertex/container';
-import type { Cursor, FederatedMouseEvent } from '@/utils/visual/event/types';
+import type { Container } from "../vertex/container.js";
+import type { Cursor, FederatedMouseEvent } from "./types.js";
 export declare class EventBoundary {
     private rootContainer;
     private hasFoundTarget;

package/dist/src/utils/visual/event/boundary.js

@@ -0,0 +1,93 @@
+import { EventPhase as o } from "./types.js";
+var p = class {
+  rootContainer;
+  hasFoundTarget = !1;
+  hitTarget = null;
+  cursor = "auto";
+  eventHandlerMap = {};
+  pressTargetsMap = {};
+  overTargets = [];
+  constructor(t) {
+    this.rootContainer = t, this.eventHandlerMap.mousemove = this.fireMouseMove, this.eventHandlerMap.mousedown = this.fireMouseDown, this.eventHandlerMap.mouseup = this.fireMouseUp;
+  }
+  hitTestRecursive = (t, r) => {
+    if (!t.visible || this.hasFoundTarget) return;
+    for (let s = t.children.length - 1; s >= 0; s--) {
+      const i = t.children[s];
+      this.hitTestRecursive(i, r);
+    }
+    if (this.hasFoundTarget) return;
+    const a = t.worldTransform.applyInverse(r);
+    t.containsPoint(a) && (this.hitTarget = t, this.hasFoundTarget = !0);
+  };
+  hitTest = (t) => (this.hasFoundTarget = !1, this.hitTarget = null, this.hitTestRecursive(this.rootContainer, t), this.hitTarget);
+  fireEvent = (t) => {
+    this.eventHandlerMap[t.type]?.(t);
+  };
+  fireMouseMove = (t) => {
+    const r = this.hitTest(t.global), a = this.overTargets.length > 0 ? this.overTargets[this.overTargets.length - 1] : null;
+    if (a && a !== r && (t.target = a, t.type = "mouseout", this.dispatchEvent(t), !r || !this.composePath(r).includes(a)))
+      if (t.type = "mouseleave", t.eventPhase = o.AT_TARGET, r) {
+        let s = a;
+        for (; s && !this.composePath(r).includes(s); )
+          t.target = s, t.currentTarget = t.target, t.target.call(`${t.type}capture`, t), t.target.call(t.type, t), s = s.parent;
+      } else
+        for (let s = this.overTargets.length - 1; s >= 0; s--)
+          t.target = this.overTargets[s], t.currentTarget = t.target, t.target.call(`${t.type}capture`, t), t.target.call(t.type, t);
+    if (r && a !== r) {
+      t.target = r, t.type = "mouseover", this.dispatchEvent(t);
+      const s = this.composePath(r);
+      if (t.type = "mouseenter", t.eventPhase = o.AT_TARGET, a) {
+        let i = s.length - 1;
+        for (; i >= 0 && !this.composePath(a).includes(s[i]); i--) ;
+        for (let e = i + 1; e < s.length; e++)
+          t.target = s[e], t.currentTarget = t.target, t.target.call(`${t.type}capture`, t), t.target.call(t.type, t);
+      } else
+        for (let i = 0; i < s.length; i++)
+          t.target = s[i], t.currentTarget = t.target, t.target.call(`${t.type}capture`, t), t.target.call(t.type, t);
+    }
+    r && (t.target = r, t.type = "mousemove", this.dispatchEvent(t)), this.overTargets = r ? this.composePath(r) : [], r ? this.cursor = r.cursor : this.cursor = "auto";
+  };
+  fireMouseDown = (t) => {
+    const r = this.hitTest(t.global);
+    r && (t.target = r, this.dispatchEvent(t), this.pressTargetsMap[t.button] = this.composePath(r));
+  };
+  fireMouseUp = (t) => {
+    const r = this.hitTest(t.global);
+    if (!r) return;
+    t.target = r, this.dispatchEvent(t);
+    const a = this.pressTargetsMap[t.button];
+    if (!a) return;
+    let s = a[a.length - 1];
+    const i = this.composePath(r);
+    for (; s && !i.includes(s); ) s.parent && (s = s.parent);
+    t.type = "click", t.target = s, this.dispatchEvent(t), delete this.pressTargetsMap[t.button];
+  };
+  notifyTarget = (t) => {
+    t.eventPhase === o.CAPTURING ? t.currentTarget.call(`${t.type}capture`, t) : t.currentTarget.call(t.type, t);
+  };
+  propagate = (t) => {
+    const r = this.composePath(t.target);
+    t.eventPhase = o.CAPTURING;
+    for (let a = 0; a < r.length - 1; a++)
+      if (t.currentTarget = r[a], this.notifyTarget(t), t.propagationStopped) return;
+    if (t.eventPhase = o.AT_TARGET, t.currentTarget = t.target, t.currentTarget.call(`${t.type}capture`, t), !t.propagationStopped && (t.currentTarget.call(t.type, t), !t.propagationStopped)) {
+      t.eventPhase = o.BUBBLING;
+      for (let a = r.length - 2; a >= 0; a--)
+        if (t.currentTarget = r[a], this.notifyTarget(t), t.propagationStopped) return;
+    }
+  };
+  dispatchEvent = (t) => {
+    t.propagationStopped = !1, this.propagate(t);
+  };
+  composePath = (t) => {
+    const r = [];
+    let a = t;
+    for (; a; )
+      r.unshift(a), a = a.parent;
+    return r;
+  };
+};
+export {
+  p as EventBoundary
+};

package/dist/src/utils/visual/event/event.d.ts

@@ -1,4 +1,4 @@
-import type { Container } from '@/utils/visual/vertex/container';
+import type { Container } from "../vertex/container.js";
 export declare class EventSystem {
     private canvasEle;
     private eventBoundary;

package/dist/src/utils/visual/event/event.js

@@ -0,0 +1,34 @@
+import { FederatedMouseEvent as o } from "./types.js";
+import { EventBoundary as n } from "./boundary.js";
+var i = class {
+  canvasEle;
+  eventBoundary;
+  rootEvent = new o();
+  constructor(t, e) {
+    this.canvasEle = t, this.eventBoundary = new n(e), this.addEvents();
+  }
+  addEvents = () => {
+    this.canvasEle.addEventListener("pointermove", this.onPointerMove, !0), this.canvasEle.addEventListener("pointerleave", this.onPointerLeave, !0), this.canvasEle.addEventListener("pointerdown", this.onPointerDown, !0), this.canvasEle.addEventListener("pointerup", this.onPointerup, !0);
+  };
+  onPointerMove = (t) => {
+    this.bootstrapEvent(t), this.eventBoundary.fireEvent(this.rootEvent), this.setCursor();
+  };
+  onPointerLeave = () => {
+    this.eventBoundary.overTargets = [];
+  };
+  onPointerDown = (t) => {
+    this.bootstrapEvent(t), this.eventBoundary.fireEvent(this.rootEvent);
+  };
+  onPointerup = (t) => {
+    this.bootstrapEvent(t), this.eventBoundary.fireEvent(this.rootEvent);
+  };
+  bootstrapEvent = (t) => {
+    this.rootEvent.isTrusted = t.isTrusted, this.rootEvent.timeStamp = performance.now(), this.rootEvent.type = t.type.replace("pointer", "mouse"), this.rootEvent.button = t.button, this.rootEvent.buttons = t.buttons, this.rootEvent.global.x = t.offsetX, this.rootEvent.global.y = t.offsetY;
+  };
+  setCursor = () => {
+    this.canvasEle.style.cursor = this.eventBoundary.cursor;
+  };
+};
+export {
+  i as EventSystem
+};

package/dist/src/utils/visual/event/index.d.ts

@@ -1,6 +1,6 @@
-import { EventBoundary } from '@/utils/visual/event/boundary';
-import { EventSystem } from '@/utils/visual/event/event';
-import { EventPhase, FederatedMouseEvent } from '@/utils/visual/event/types';
-import type { Cursor, FederatedEventMap } from '@/utils/visual/event/types';
+import { EventBoundary } from "./boundary.js";
+import { EventSystem } from "./event.js";
+import { EventPhase, FederatedMouseEvent } from "./types.js";
+import type { Cursor, FederatedEventMap } from "./types.js";
 export { EventBoundary, EventSystem, EventPhase, FederatedMouseEvent };
 export type { FederatedEventMap, Cursor };

package/dist/src/utils/visual/event/types.d.ts

@@ -1,5 +1,5 @@
-import { Point } from '@/utils/visual/vertex/point';
-import { Container } from '@/utils/visual/vertex/container';
+import { Point } from "../vertex/point.js";
+import { Container } from "../vertex/container.js";
 export declare enum EventPhase {
     NONE = 0,
     CAPTURING = 1,

package/dist/src/utils/visual/event/types.js

@@ -0,0 +1,23 @@
+import { Point as r } from "../vertex/point.js";
+import { Container as o } from "../vertex/container.js";
+var i = /* @__PURE__ */ (function(t) {
+  return t[t.NONE = 0] = "NONE", t[t.CAPTURING = 1] = "CAPTURING", t[t.AT_TARGET = 2] = "AT_TARGET", t[t.BUBBLING = 3] = "BUBBLING", t;
+})({}), a = class {
+  isTrusted = !0;
+  timeStamp = 0;
+  type = "mousemove";
+  button = 0;
+  buttons = 0;
+  global = new r();
+  propagationStopped = !1;
+  eventPhase = 0;
+  target = new o();
+  currentTarget = new o();
+  stopPropagation() {
+    this.propagationStopped = !0;
+  }
+};
+export {
+  i as EventPhase,
+  a as FederatedMouseEvent
+};

package/dist/src/utils/visual/graphics/graphics.d.ts

@@ -1,11 +1,11 @@
-import { Container } from '@/utils/visual/vertex/container';
-import { Polygon } from '@/utils/visual/shape/polygon';
-import { GraphicsGeometry } from '@/utils/visual/graphics/graphicsGeometry';
-import type { Shape } from '@/utils/visual/shape/shape';
-import type { BatchRenderer } from '@/utils/visual/render/batchRenderer';
-import type { ILineStyleOptions } from '@/utils/visual/types';
-import type { CanvasRenderer } from '@/utils/visual/render/canvasRenderer';
-import type { Point } from '@/utils/visual/vertex/point';
+import { Container } from "../vertex/container.js";
+import { Polygon } from "../shape/polygon.js";
+import { GraphicsGeometry } from "./graphicsGeometry.js";
+import type { Shape } from "../shape/shape.js";
+import type { BatchRenderer } from "../render/batchRenderer.js";
+import type { ILineStyleOptions } from "../types.js";
+import type { CanvasRenderer } from "../render/canvasRenderer.js";
+import type { Point } from "../vertex/point.js";
 export declare class Graphics extends Container {
     private _lineStyle;
     private _fillStyle;

package/dist/src/utils/visual/graphics/graphics.js

@@ -0,0 +1,168 @@
+import { GRAPHICS as Y } from "../enums.js";
+import { Rectangle as v } from "../shape/rectangle.js";
+import { batchPool as L } from "../render/utils/batch/index.js";
+import { toRgbaLittleEndian as j } from "../render/utils/index.js";
+import { getBezierLength as q, getQuadraticBezierLength as B } from "../math/bezier.js";
+import { Container as D } from "../vertex/container.js";
+import { Polygon as S } from "../shape/polygon.js";
+import { Fill as G } from "../style/fill.js";
+import { Line as O } from "../style/line.js";
+import { Circle as M } from "../shape/circle.js";
+import { Ellipse as I } from "../shape/ellipse.js";
+import { RoundedRectangle as T } from "../shape/roundedRectangle.js";
+import { GraphicsGeometry as z } from "./graphicsGeometry.js";
+var it = class extends D {
+  _lineStyle = new O();
+  _fillStyle = new G();
+  geometry = new z();
+  currentPath = new S();
+  type;
+  constructor() {
+    super(), this.type = Y;
+  }
+  lineStyle(i, t = "#000000", e = 1) {
+    if (this.startPoly(), typeof i == "object") Object.assign(this._lineStyle, i);
+    else {
+      const n = {
+        width: i,
+        color: t,
+        alpha: e
+      };
+      Object.assign(this._lineStyle, n);
+    }
+    return this._lineStyle.visible = !0, this;
+  }
+  resetLineStyle = () => {
+    this._lineStyle.reset();
+  };
+  drawShape = (i) => (this.geometry.drawShape(i, this._fillStyle.clone(), this._lineStyle.clone()), this.markStructureDirty(), this);
+  startPoly = () => {
+    this.currentPath.points.length > 2 && this.drawShape(this.currentPath), this.currentPath = new S();
+  };
+  beginFill = (i = "#000000", t = 1) => (this.startPoly(), this._fillStyle.color = i, this._fillStyle.alpha = t, this._fillStyle.alpha > 0 && (this._fillStyle.visible = !0), this);
+  endFill = () => (this.startPoly(), this._fillStyle.reset(), this);
+  drawRect = (i, t, e, n) => this.drawShape(new v(i, t, e, n));
+  drawCircle = (i, t, e) => this.drawShape(new M(i, t, e));
+  drawRoundedRect = (i, t, e, n, l) => this.drawShape(new T(i, t, e, n, l));
+  drawEllipse = (i, t, e, n) => this.drawShape(new I(i, t, e, n));
+  drawPolygon = (i) => {
+    const t = new S(i);
+    return t.closeStroke = !0, this.drawShape(t);
+  };
+  moveTo = (i, t) => (this.startPoly(), this.currentPath.points[0] = i, this.currentPath.points[1] = t, this);
+  lineTo = (i, t) => {
+    if (this.currentPath.points.length === 0)
+      return this.moveTo(i, t), this;
+    const e = this.currentPath.points, n = e[e.length - 2], l = e[e.length - 1];
+    return (n !== i || l !== t) && e.push(i, t), this;
+  };
+  closePath = () => (this.currentPath.closeStroke = !0, this.startPoly(), this);
+  containsPoint = (i) => this.hitArea ? this.hitArea.contains(i) : this.geometry.containsPoint(i);
+  quadraticCurveTo = (i, t, e, n) => {
+    const l = this.currentPath.points.length;
+    l === 0 && (this.currentPath.points = [0, 0]);
+    const y = this.currentPath.points[l - 2], P = this.currentPath.points[l - 1], b = i, m = t, d = e, h = n, r = B(y, P, b, m, d, h);
+    let c = Math.ceil(r / 10);
+    c > 2048 && (c = 2048), c < 8 && (c = 8);
+    for (let o = 1; o <= c; o++) {
+      const s = o / c, p = (1 - s) * (1 - s) * y + 2 * s * (1 - s) * b + s * s * d, f = (1 - s) * (1 - s) * P + 2 * s * (1 - s) * m + s * s * h;
+      this.currentPath.points.push(p, f);
+    }
+    return this;
+  };
+  bezierCurveTo = (i, t, e, n, l, y) => {
+    const P = this.currentPath.points.length;
+    P === 0 && (this.currentPath.points = [0, 0]);
+    const b = this.currentPath.points[P - 2], m = this.currentPath.points[P - 1], d = i, h = t, r = e, c = n, o = l, s = y, p = q(b, m, d, h, r, c, o, s);
+    let f = Math.ceil(p / 10);
+    f > 2048 && (f = 2048), f < 8 && (f = 8);
+    for (let u = 1; u <= f; u++) {
+      const a = u / f, w = (1 - a) * (1 - a) * (1 - a) * b + 3 * a * (1 - a) * (1 - a) * d + 3 * a * a * (1 - a) * r + a * a * a * o, g = (1 - a) * (1 - a) * (1 - a) * m + 3 * a * (1 - a) * (1 - a) * h + 3 * a * a * (1 - a) * c + a * a * a * s;
+      this.currentPath.points.push(w, g);
+    }
+    return this;
+  };
+  arc = (i, t, e, n, l, y = !1) => {
+    if (!y) {
+      for (; l < n; ) l += Math.PI * 2;
+      l - n > Math.PI * 2 && (l = n + Math.PI * 2);
+    }
+    if (y) {
+      for (; l > n; ) n += Math.PI * 2;
+      n - l > Math.PI * 2 && (l = n - Math.PI * 2);
+    }
+    const P = l - n;
+    if (P === 0) return this;
+    const b = i + Math.cos(n) * e, m = t + Math.sin(n) * e;
+    this.lineTo(b, m);
+    const d = Math.abs(P) * e;
+    let h = Math.ceil(d / 10);
+    h > 2048 && (h = 2048), h < 8 && (h = 8);
+    for (let r = 1; r <= h; r++) {
+      const c = n + P * (r / h), o = i + Math.cos(c) * e, s = t + Math.sin(c) * e;
+      this.lineTo(o, s);
+    }
+    return this;
+  };
+  arcTo = (i, t, e, n, l) => {
+    if (!this.currentPath) return this;
+    const y = this.currentPath.points.length;
+    if (y === 0 || l === 0)
+      return this.lineTo(i, t), this;
+    const P = this.currentPath.points[y - 1] - t, b = this.currentPath.points[y - 2] - i, m = n - t, d = e - i, h = P * d - b * m, r = Math.abs(h);
+    if (r < 1e-8)
+      return this.lineTo(i, t), this;
+    const c = P * P + b * b, o = m * m + d * d, s = P * m + b * d, p = l * Math.sqrt(c) / r, f = l * Math.sqrt(o) / r, u = p * s / c, a = f * s / o, w = p * d + f * b, g = p * m + f * P, C = b * (f + u), x = P * (f + u), _ = d * (p + a), k = m * (p + a), A = Math.atan2(x - g, C - w), R = Math.atan2(k - g, _ - w), X = b * m > d * P;
+    return this.arc(w + i, g + t, l, A, R, X);
+  };
+  clear = () => (this.geometry.clear(), this._lineStyle.reset(), this._fillStyle.reset(), this.currentPath = new S(), this.batches = [], this.batchCount = 0, this.markStructureDirty(), this);
+  renderCanvas = (i) => {
+    this.startPoly();
+    const t = i.ctx, { a: e, b: n, c: l, d: y, tx: P, ty: b } = this.transform.worldTransform;
+    t.setTransform(e, n, l, y, P, b);
+    const m = this.geometry.graphicsData;
+    for (let d = 0; d < m.length; d++) {
+      const { lineStyle: h, fillStyle: r, shape: c } = m[d];
+      if (r.visible && (t.fillStyle = r.color), h.visible && (t.lineWidth = h.width, t.lineCap = h.cap, t.lineJoin = h.join, t.strokeStyle = h.color), t.beginPath(), c instanceof v) {
+        const { x: o, y: s, width: p, height: f } = c;
+        r.visible && (t.globalAlpha = r.alpha * this.worldAlpha, t.fillRect(o, s, p, f)), h.visible && (t.globalAlpha = h.alpha * this.worldAlpha, t.strokeRect(o, s, p, f));
+      }
+      if (c instanceof M) {
+        const { x: o, y: s, radius: p } = c;
+        t.arc(o, s, p, 0, 2 * Math.PI), r.visible && (t.globalAlpha = r.alpha * this.worldAlpha, t.fill()), h.visible && (t.globalAlpha = h.alpha * this.worldAlpha, t.stroke());
+      }
+      if (c instanceof T) {
+        const { x: o, y: s, width: p, height: f, radius: u } = c;
+        t.moveTo(o + u, s), t.arc(o + u, s + u, u, Math.PI * 1.5, Math.PI, !0), t.lineTo(o, s + f - u), t.arc(o + u, s + f - u, u, Math.PI, Math.PI / 2, !0), t.lineTo(o + p - u, s + f), t.arc(o + p - u, s + f - u, u, Math.PI / 2, 0, !0), t.lineTo(o + p, s + u), t.arc(o + p - u, s + u, u, 0, Math.PI * 1.5, !0), t.closePath(), r.visible && (t.globalAlpha = r.alpha * this.worldAlpha, t.fill()), h.visible && (t.globalAlpha = h.alpha * this.worldAlpha, t.stroke());
+      }
+      if (c instanceof I) {
+        const { x: o, y: s, radiusX: p, radiusY: f } = c;
+        t.ellipse(o, s, p, f, 0, 0, Math.PI * 2), r.visible && (t.globalAlpha = r.alpha * this.worldAlpha, t.fill()), h.visible && (t.globalAlpha = h.alpha * this.worldAlpha, t.stroke());
+      }
+      if (c instanceof S) {
+        const { points: o, closeStroke: s } = c;
+        t.moveTo(o[0], o[1]);
+        for (let p = 2; p < o.length; p += 2) t.lineTo(o[p], o[p + 1]);
+        s && t.closePath(), r.visible && (t.globalAlpha = r.alpha * this.worldAlpha, t.fill()), h.visible && (t.globalAlpha = h.alpha * this.worldAlpha, t.stroke());
+      }
+    }
+  };
+  buildBatches = (i) => {
+    this.startPoly(), this.worldId = this.transform.worldId, this.geometry.buildVerticesAndTriangulate();
+    const t = this.geometry.batchParts;
+    for (let e = 0; e < t.length; e++) {
+      const { style: n, vertexStart: l, vertexCount: y, indexStart: P, indexCount: b } = t[e], { color: m, alpha: d } = n, h = j(m, d * this.worldAlpha), r = L.get(this.type);
+      r.vertexCount = y, r.indexCount = b, r.rgba = h, r.vertexOffset = l, r.indexOffset = P, r.graphics = this, this.batches[e] = r, i.addBatch(this.batches[e]);
+    }
+    this.batchCount = t.length;
+  };
+  updateBatches = (i) => {
+    if (this.worldId !== this.transform.worldId) {
+      this.worldId = this.transform.worldId;
+      for (let t = 0; t < this.batchCount; t++) this.batches[t].updateVertices(i);
+    }
+  };
+};
+export {
+  it as Graphics
+};

package/dist/src/utils/visual/graphics/graphicsData.d.ts

@@ -1,6 +1,6 @@
-import type { Shape } from '@/utils/visual/shape/shape';
-import type { Fill } from '@/utils/visual/style/fill';
-import type { Line } from '@/utils/visual/style/line';
+import type { Shape } from "../shape/shape.js";
+import type { Fill } from "../style/fill.js";
+import type { Line } from "../style/line.js";
 export declare class GraphicsData {
     shape: Shape;
     lineStyle: Line;

package/dist/src/utils/visual/graphics/graphicsData.js

@@ -0,0 +1,12 @@
+var s = class {
+  shape;
+  lineStyle;
+  fillStyle;
+  vertices = [];
+  constructor(t, e, l) {
+    this.shape = t, this.lineStyle = l, this.fillStyle = e;
+  }
+};
+export {
+  s as GraphicsData
+};

package/dist/src/utils/visual/graphics/graphicsGeometry.d.ts

@@ -1,10 +1,10 @@
-import { GraphicsData } from '@/utils/visual/graphics/graphicsData';
-import { CustomFloatArray, CustomIntArray } from '@/utils/visual/render/utils/float';
-import type { Point } from '@/utils/visual/vertex/point';
-import type { BatchPart } from '@/utils/visual/render/utils/batch';
-import type { Shape } from '@/utils/visual/shape/shape';
-import type { Fill } from '@/utils/visual/style/fill';
-import type { Line } from '@/utils/visual/style/line';
+import { GraphicsData } from "./graphicsData.js";
+import { CustomFloatArray, CustomIntArray } from "../render/utils/float.js";
+import type { Point } from "../vertex/point.js";
+import type { BatchPart } from "../render/utils/batch/index.js";
+import type { Shape } from "../shape/shape.js";
+import type { Fill } from "../style/fill.js";
+import type { Line } from "../style/line.js";
 export declare class GraphicsGeometry {
     graphicsData: GraphicsData[];
     private dirty;

package/dist/src/utils/visual/graphics/graphicsGeometry.js

@@ -0,0 +1,39 @@
+import { GraphicsData as e } from "./graphicsData.js";
+import { CustomFloatArray as r, CustomIntArray as h } from "../render/utils/float.js";
+import { buildVertices as l, triangulateFill as n, triangulateStroke as c } from "../render/utils/verticy.js";
+var f = class {
+  graphicsData = [];
+  dirty = !1;
+  shapeIndex = 0;
+  batchParts = [];
+  vertices = new r();
+  indices = new h();
+  drawShape(i, t, a) {
+    const s = new e(i, t, a);
+    this.graphicsData.push(s), this.dirty = !0;
+  }
+  containsPoint(i) {
+    for (let t = 0; t < this.graphicsData.length; t++) {
+      const { shape: a, fillStyle: s } = this.graphicsData[t];
+      if (s.visible && a.contains(i))
+        return !0;
+    }
+    return !1;
+  }
+  buildVerticesAndTriangulate() {
+    if (this.dirty) {
+      this.dirty = !1;
+      for (let i = this.shapeIndex; i < this.graphicsData.length; i++) {
+        const t = this.graphicsData[i];
+        l(t), t.fillStyle.visible && n(t, this), t.lineStyle.visible && c(t, this);
+      }
+      this.shapeIndex = this.graphicsData.length;
+    }
+  }
+  clear() {
+    this.graphicsData = [], this.vertices.clear(), this.indices.clear(), this.batchParts = [], this.shapeIndex = 0, this.dirty = !1;
+  }
+};
+export {
+  f as GraphicsGeometry
+};

package/dist/src/utils/visual/graphics/index.d.ts

@@ -1,4 +1,4 @@
-import { Graphics } from '@/utils/visual/graphics/graphics';
-import { GraphicsData } from '@/utils/visual/graphics/graphicsData';
-import { GraphicsGeometry } from '@/utils/visual/graphics/graphicsGeometry';
+import { Graphics } from "./graphics.js";
+import { GraphicsData } from "./graphicsData.js";
+import { GraphicsGeometry } from "./graphicsGeometry.js";
 export { Graphics, GraphicsData, GraphicsGeometry };

package/dist/src/utils/visual/index.d.ts

@@ -1,10 +1,10 @@
-import { Application } from '@/utils/visual/application';
-import { Container } from '@/utils/visual/vertex/container';
-import { Graphics } from '@/utils/visual/graphics/graphics';
-import { ColorAdjustFilter, Filter } from '@/utils/visual/render/filter';
-import { WebGLRenderTarget } from '@/utils/visual/render/renderTarget';
-import { BYTES_PER_VERTEX, LINE_CAP, LINE_JOIN, MAX_VERTEX_COUNT, RENDERER_TYPE, SHAPE_TYPE } from '@/utils/visual/enums';
-import type { IApplicationOptions, IFillStyleOptions, ILineStyleOptions } from '@/utils/visual/types';
-import type { ColorAdjustOptions } from '@/utils/visual/render/filter';
+import { Application } from "./application.js";
+import { Container } from "./vertex/container.js";
+import { Graphics } from "./graphics/graphics.js";
+import { ColorAdjustFilter, Filter } from "./render/filter.js";
+import { WebGLRenderTarget } from "./render/renderTarget.js";
+import { BYTES_PER_VERTEX, LINE_CAP, LINE_JOIN, MAX_VERTEX_COUNT, RENDERER_TYPE, SHAPE_TYPE } from "./enums.js";
+import type { IApplicationOptions, IFillStyleOptions, ILineStyleOptions } from "./types.js";
+import type { ColorAdjustOptions } from "./render/filter.js";
 export { Application, Container, Graphics, Filter, ColorAdjustFilter, WebGLRenderTarget, SHAPE_TYPE, LINE_CAP, LINE_JOIN, RENDERER_TYPE, MAX_VERTEX_COUNT, BYTES_PER_VERTEX, };
 export type { IApplicationOptions, IFillStyleOptions, ILineStyleOptions, ColorAdjustOptions };