@funnest/charts 0.6.25 → 0.6.27

package/dist/chart.d.ts

@@ -2,7 +2,7 @@ import { type Locale } from './model/time-format';
 import { TimeScale, type IndexRange, type TimeScaleOptions } from './model/time-scale';
 import type { IndicatorDefinition, IndicatorParams, IndicatorType } from './indicators/definitions';
 import { type IndicatorConfig, type IndicatorPatch } from './indicators/manager';
-import { type Drawing, type DrawingDefinition, type DrawingType } from './objects/drawings';
+import { type Drawing, type DrawingDefaults, type DrawingDefinition, type DrawingType } from './objects/drawings';
 import { type AlertLineOptions, type ExecutionMarker, type LineHandle, type OrderLineOptions, type PositionLineOptions, type TradingLabelOptions } from './objects/trading';
 import { type ChartSettings, type ChartState } from './settings';
 import { type TradingAdapter } from './objects/trading-sync';
@@ -77,8 +77,14 @@ export interface ChartEvents {
     loadingChange: boolean;
     /** Drawings were created, edited or removed (not fired during a live drag). */
     drawingsChange: Drawing[];
-    /** The armed drawing tool changed (null = cursor). Tools disarm after one drawing. */
+    /** The armed drawing tool changed (null = cursor). Tools disarm after one drawing (unless `keepDrawingTool`). */
     drawingToolChange: DrawingType | null;
+    /** All drawings hidden (true) or shown again. */
+    drawingsHiddenChange: boolean;
+    /** 연속 그리기 turned on or off. */
+    keepDrawingToolChange: boolean;
+    /** A tool's last color / style changed (save it to restore with `setDrawingDefaults`). */
+    drawingDefaultsChange: DrawingDefaults;
     selectionChange: Drawing | null;
     magnetChange: boolean;
     chartTypeChange: ChartType;
@@ -358,6 +364,16 @@ export declare class Chart {
     /** Arms a drawing tool (null = cursor). It disarms itself after one drawing is placed. */
     setDrawingTool(tool: DrawingType | null): void;
     get drawingTool(): DrawingType | null;
+    /** Hides every drawing (not drawn, not clickable) or shows them again. Arming a tool shows them. */
+    setDrawingsHidden(hidden: boolean): void;
+    get drawingsHidden(): boolean;
+    /** 연속 그리기: the armed tool stays armed after each drawing (Esc or the cursor drops it). */
+    setKeepDrawingTool(on: boolean): void;
+    get keepDrawingTool(): boolean;
+    /** Each tool's last color / line / text style; new drawings of a tool start with it. */
+    getDrawingDefaults(): DrawingDefaults;
+    /** Restores them (e.g. from storage). Doesn't fire drawingDefaultsChange. */
+    setDrawingDefaults(defaults: DrawingDefaults): void;
     /** Magnet mode: drawing points snap to the nearest open/high/low/close of the bar. */
     setMagnet(on: boolean): void;
     get magnetEnabled(): boolean;

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export type { FormatPriceOptions } from './price';
 export { decimalsOf, formatCompact, formatPrice, krxTickSize, resolveTickSize, roundToTick } from './price';
 export { isIntradayResolution, resolutionLabel, resolutionToMs } from './resolution';
 export type { ChartType } from './render/renderer';
-export type { BuiltinDrawingType, Drawing, DrawingDefinition, DrawingGeometry, DrawingPoint, DrawingRenderContext, DrawingStyle, DrawingColorSlot, DrawingType, } from './objects/drawings';
+export type { BuiltinDrawingType, Drawing, DrawingDefaults, DrawingDefinition, DrawingGeometry, DrawingPoint, DrawingRenderContext, DrawingStyle, DrawingColorSlot, DrawingType, } from './objects/drawings';
 export { BUILTIN_DRAWINGS, distToSegment, FIB_LEVELS } from './objects/drawings';
 export type { ChartOverlay, ObjectRenderContext, PaneCoords } from './objects/types';
 export type { Painter } from './render/painter';

package/dist/index.js

@@ -1312,6 +1312,7 @@ function drawingRegistry(extra = []) {
   for (const def of extra) registry.set(def.type, def);
   return registry;
 }
+var CLOSE_PX = 7;
 var DrawingManager = class {
   constructor(onChange, registry = drawingRegistry()) {
     this.onChange = onChange;
@@ -1322,6 +1323,11 @@ var DrawingManager = class {
   drawings = [];
   tool = null;
   selectedId = null;
+  /** Every drawing hidden at once (arming a tool shows them again). */
+  hiddenAll = false;
+  /** The tool stays armed after a drawing is placed (연속 그리기). */
+  keepTool = false;
+  defaults = {};
   draft = null;
   freehandLast = null;
   drag = null;
@@ -1333,8 +1339,15 @@ var DrawingManager = class {
     this.tool = tool;
     this.draft = null;
     if (tool) this.selectedId = null;
+    if (tool && this.hiddenAll) this.setHiddenAll(false);
     this.onChange("tool");
   }
+  setHiddenAll(hidden) {
+    if (hidden === this.hiddenAll) return;
+    this.hiddenAll = hidden;
+    if (hidden) this.selectedId = null;
+    this.onChange("hidden");
+  }
   select(id) {
     if (id === this.selectedId) return;
     this.selectedId = id;
@@ -1350,6 +1363,12 @@ var DrawingManager = class {
     const d = this.drawings.find((x) => x.id === id);
     if (!d) return;
     Object.assign(d, patch);
+    if ("color" in patch || patch.style) {
+      const { width, dash, fontSize } = d.style ?? {};
+      const style = Object.fromEntries(Object.entries({ width, dash, fontSize }).filter(([, v]) => v !== void 0));
+      this.defaults = { ...this.defaults, [d.type]: { ...d.color ? { color: d.color } : {}, ...Object.keys(style).length ? { style } : {} } };
+      this.onChange("defaults");
+    }
     this.onChange("commit");
   }
   remove(id) {
@@ -1364,13 +1383,24 @@ var DrawingManager = class {
     this.draft = null;
     this.onChange("commit");
   }
-  /** Esc: abort an in-progress drawing, else drop the tool, else deselect. */
+  /** Esc: finish a path that has enough points, else abort an in-progress drawing, else drop the tool, else deselect. */
   cancel() {
+    if (this.finishOpen()) return;
     if (this.draft || this.tool) this.setTool(null);
     else this.select(null);
   }
+  /** Finishes an `open` tool's drawing in progress (Enter); false when there is none or too few points. */
+  finishOpen() {
+    const draft = this.draft;
+    const def = draft && this.registry.get(draft.drawing.type);
+    if (!draft || !def?.open || draft.placed.length < Math.max(2, def.clicks)) return false;
+    draft.drawing.points = draft.placed.map((p) => ({ ...p }));
+    this.finish();
+    return true;
+  }
   // ── Creation ──────────────────────────────────────────────────────
   expand(def, placed, c) {
+    if (def.open) return placed.map((p) => ({ ...p }));
     const full = Array.from({ length: def.clicks }, (_, i) => ({ ...placed[i] ?? placed[placed.length - 1] }));
     return def.create ? def.create(full, c) : full;
   }
@@ -1387,11 +1417,28 @@ var DrawingManager = class {
     }
     if (!this.draft) {
       const placed = [point];
-      this.draft = { drawing: { id: newId("d"), type: def.type, points: this.expand(def, placed, c) }, placed };
-      if (def.clicks <= 1) this.finish();
+      const last = this.defaults[def.type];
+      this.draft = {
+        drawing: { id: newId("d"), type: def.type, points: this.expand(def, placed, c), ...last?.color ? { color: last.color } : {}, ...last?.style ? { style: { ...last.style } } : {} },
+        placed
+      };
+      if (def.clicks <= 1 && !def.open) this.finish();
       else this.onChange("preview");
       return;
     }
+    if (def.open) {
+      const near = (p) => Math.hypot(c.timeToX(p.time) - x, c.priceToY(p.price) - y) <= CLOSE_PX;
+      const placed = this.draft.placed;
+      if (placed.length >= Math.max(2, def.clicks) && (near(placed[placed.length - 1]) || near(placed[0]))) {
+        this.finishOpen();
+        return;
+      }
+      if (near(placed[placed.length - 1])) return;
+      placed.push(point);
+      this.draft.drawing.points = [...placed.map((p) => ({ ...p })), { ...point }];
+      this.onChange("preview");
+      return;
+    }
     this.draft.placed.push(point);
     this.draft.drawing.points = this.expand(def, this.draft.placed, c);
     if (this.draft.placed.length >= def.clicks) this.finish();
@@ -1410,7 +1457,7 @@ var DrawingManager = class {
       this.onChange("preview");
       return;
     }
-    draft.drawing.points = this.expand(def, [...draft.placed, c.pointAt(x, y)], c);
+    draft.drawing.points = def.open ? [...draft.placed.map((p) => ({ ...p })), c.pointAt(x, y)] : this.expand(def, [...draft.placed, c.pointAt(x, y)], c);
     this.onChange("preview");
   }
   /** Pointer released: a drag since the first point places the next one (drag-to-draw). */
@@ -1426,6 +1473,10 @@ var DrawingManager = class {
     const drawing = this.draft.drawing;
     this.draft = null;
     this.drawings.push(drawing);
+    if (this.keepTool) {
+      this.onChange("commit");
+      return;
+    }
     this.selectedId = drawing.id;
     this.tool = null;
     this.onChange("tool");
@@ -1446,8 +1497,10 @@ var DrawingManager = class {
       const handle = this.handles(c, selected).findIndex(([px, py]) => Math.hypot(px - x, py - y) <= HANDLE_RADIUS + tolerance);
       if (handle >= 0) return { kind: "drawing", id: selected.id, part: handle };
     }
+    if (this.hiddenAll) return null;
     for (let i = this.drawings.length - 1; i >= 0; i--) {
       const d = this.drawings[i];
+      if (d.style?.hidden) continue;
       const def = this.registry.get(d.type);
       if (def && def.distance(this.geometry(c, d), x, y) <= tolerance) return { kind: "drawing", id: d.id, part: "body" };
     }
@@ -1481,7 +1534,8 @@ var DrawingManager = class {
   }
   // ── Rendering ─────────────────────────────────────────────────────
   render(rc, badges, bars = [], barIndexAt = () => -1) {
-    const all = this.draft ? [...this.drawings, this.draft.drawing] : this.drawings;
+    const shown = this.hiddenAll ? [] : this.drawings.filter((d) => !d.style?.hidden);
+    const all = this.draft ? [...shown, this.draft.drawing] : shown;
     const c = rc.coords;
     for (const d of all) {
       const def = this.registry.get(d.type);
@@ -1919,6 +1973,12 @@ var CHART_THEMES = [
     name: { ko: "\uB525 \uB124\uC774\uBE44", en: "Deep navy" },
     colors: { upColor: "#FF5A5F", downColor: "#4C8DFF", background: "#0F1A2E", gridColor: "#1B2A44", textColor: "#C8D3E6" }
   },
+  {
+    // True black (OLED): the darkest, with a barely-there grid.
+    id: "deep-dark",
+    name: { ko: "\uB525 \uB2E4\uD06C", en: "Deep dark" },
+    colors: { upColor: "#F04452", downColor: "#3182F6", background: "#000000", gridColor: "#121212", textColor: "#B8BCC4" }
+  },
   {
     id: "mono",
     name: { ko: "\uBAA8\uB178", en: "Mono" },
@@ -3024,6 +3084,9 @@ var Chart = class {
         this.recordHistory();
       }
       if (change === "tool") this.emitter.emit("drawingToolChange", this.drawings.tool);
+      if (change === "hidden") this.emitter.emit("drawingsHiddenChange", this.drawings.hiddenAll);
+      if (change === "defaults") this.emitter.emit("drawingDefaultsChange", { ...this.drawings.defaults });
+      if (change === "defaults") return;
       if (change !== "preview") {
         const d = this.drawings.selected;
         this.emitter.emit("selectionChange", d ? { ...d, points: d.points.map((p) => ({ ...p })) } : null);
@@ -3481,6 +3544,30 @@ var Chart = class {
   get drawingTool() {
     return this.drawings.tool;
   }
+  /** Hides every drawing (not drawn, not clickable) or shows them again. Arming a tool shows them. */
+  setDrawingsHidden(hidden) {
+    this.drawings.setHiddenAll(hidden);
+  }
+  get drawingsHidden() {
+    return this.drawings.hiddenAll;
+  }
+  /** 연속 그리기: the armed tool stays armed after each drawing (Esc or the cursor drops it). */
+  setKeepDrawingTool(on) {
+    if (on === this.drawings.keepTool) return;
+    this.drawings.keepTool = on;
+    this.emitter.emit("keepDrawingToolChange", on);
+  }
+  get keepDrawingTool() {
+    return this.drawings.keepTool;
+  }
+  /** Each tool's last color / line / text style; new drawings of a tool start with it. */
+  getDrawingDefaults() {
+    return JSON.parse(JSON.stringify(this.drawings.defaults));
+  }
+  /** Restores them (e.g. from storage). Doesn't fire drawingDefaultsChange. */
+  setDrawingDefaults(defaults) {
+    this.drawings.defaults = JSON.parse(JSON.stringify(defaults ?? {}));
+  }
   /** Magnet mode: drawing points snap to the nearest open/high/low/close of the bar. */
   setMagnet(on) {
     if (on === this.magnet) return;
@@ -4667,6 +4754,8 @@ var Chart = class {
         this.setReplaySelecting(false);
       } else if (e.key === "Escape" && (this.drawings.tool || this.drawings.selectedId)) {
         this.drawings.cancel();
+      } else if (e.key === "Enter" && this.drawings.finishOpen()) {
+        e.preventDefault();
       } else if ((e.key === "Delete" || e.key === "Backspace") && this.drawings.selectedId) {
         e.preventDefault();
         this.drawings.remove(this.drawings.selectedId);

package/dist/objects/drawings.d.ts

@@ -24,6 +24,8 @@ export interface DrawingStyle {
     fontSize?: number;
     /** Can't be dragged or edited until unlocked (still selectable). */
     locked?: boolean;
+    /** Not drawn and can't be hit (a drawings list can show it again). */
+    hidden?: boolean;
     /** Colors of the tool's parts (`DrawingDefinition.colors` keys), where set apart from the rest. */
     colors?: Record<string, string>;
 }
@@ -89,8 +91,13 @@ export interface DrawingDefinition {
      * are listed under it, with a divider between sections. Default: no heading.
      */
     section?: Record<Locale, string>;
-    /** Clicks (or drag ends) needed to place it. */
+    /** Clicks (or drag ends) needed to place it; with `open`, the fewest it takes. */
     clicks: number;
+    /**
+     * Placed point by point (a path, a polygon): every click adds one, until a double-click (a
+     * click on the last point), a click on the first point, Enter or Esc finishes it.
+     */
+    open?: boolean;
     /**
      * Turns the placed click points into the stored points, e.g. a position tool that creates
      * entry/target/stop from one click. Called for the live preview too. Default: as placed.
@@ -119,7 +126,12 @@ export declare function distToSegment(px: number, py: number, x1: number, y1: nu
 export declare const BUILTIN_DRAWINGS: readonly DrawingDefinition[];
 /** Built-ins plus definitions passed to the chart; later ones replace earlier ones of the same type. */
 export declare function drawingRegistry(extra?: readonly DrawingDefinition[]): Map<string, DrawingDefinition>;
-export type DrawingsChange = 'preview' | 'commit' | 'tool' | 'selection';
+export type DrawingsChange = 'preview' | 'commit' | 'tool' | 'selection' | 'defaults' | 'hidden';
+/** The last color and line / text style used per tool type: new drawings of that type start with it. */
+export type DrawingDefaults = Record<string, {
+    color?: string;
+    style?: Pick<DrawingStyle, 'width' | 'dash' | 'fontSize'>;
+}>;
 /**
  * Owns drawings: creation (click-click or drag), selection, handle/body dragging,
  * hit testing and rendering. Pure state + canvas; pointer routing lives in Interaction.
@@ -131,20 +143,28 @@ export declare class DrawingManager {
     drawings: Drawing[];
     tool: DrawingType | null;
     selectedId: string | null;
+    /** Every drawing hidden at once (arming a tool shows them again). */
+    hiddenAll: boolean;
+    /** The tool stays armed after a drawing is placed (연속 그리기). */
+    keepTool: boolean;
+    defaults: DrawingDefaults;
     private draft;
     private freehandLast;
     private drag;
     constructor(onChange: (change: DrawingsChange) => void, registry?: Map<string, DrawingDefinition>);
     get selected(): Drawing | null;
     setTool(tool: DrawingType | null): void;
+    setHiddenAll(hidden: boolean): void;
     select(id: string | null): void;
     /** Drawings of unknown types are kept (and saved) but not shown. */
     set(drawings: readonly Drawing[]): void;
     update(id: string, patch: Partial<Omit<Drawing, 'id'>>): void;
     remove(id: string): void;
     clear(): void;
-    /** Esc: abort an in-progress drawing, else drop the tool, else deselect. */
+    /** Esc: finish a path that has enough points, else abort an in-progress drawing, else drop the tool, else deselect. */
     cancel(): void;
+    /** Finishes an `open` tool's drawing in progress (Enter); false when there is none or too few points. */
+    finishOpen(): boolean;
     private expand;
     createAt(c: PaneCoords, x: number, y: number): void;
     /** Moves the not-yet-placed points (live preview while hovering or dragging). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnest/charts",
-  "version": "0.6.25",
+  "version": "0.6.27",
   "description": "Canvas charting engine for financial charts",
   "keywords": [
     "chart",