@phin-tech/dottie 0.9.0 → 0.10.0

package/dist/types/elbow.d.ts

@@ -0,0 +1,18 @@
+import type { Element } from "./model.ts";
+import type { Point, Rect } from "./path.ts";
+/** How far a route keeps from the shapes it goes round. */
+export declare const MARGIN = 16;
+/** What a bend costs, in points of length. */
+export declare const BEND = 24;
+/** Shapes smaller than this either way (packets, dots, small icons) aren't in the way. */
+export declare const SMALLEST = 24;
+/** More shapes in the way than this, and the plain route is kept. */
+export declare const MOST = 48;
+/** The box of `e` if a route goes round it: not a connector, text, freehand line or plain path, not invisible, and
+ * not small. */
+export declare function obstacle(e: Element): Rect | null;
+/** Whether the right-angled line through `points` passes through the inside of `r` (not just along its edge). */
+export declare function crosses(points: Point[], r: Rect): boolean;
+/** `plain` (the Z or L from `a` to `b`), or a way round the shapes among `elements` it crosses, leaving out `except`
+ * (the connector's own ends). */
+export declare function avoiding(plain: Point[], a: Point, b: Point, startVertical: boolean, endVertical: boolean, elements: Iterable<Element>, except: Set<string>): Point[];

package/dist/types/flows.d.ts

@@ -4,6 +4,8 @@ export declare const DEFAULT_COLOR: RGBA;
 export declare const clamp: (v: number | null, fallback: number, lo: number, hi: number) => number;
 /** The id of a flow's packet `k`: the flow's id with its last twelve digits standing for `k` (Flow.packetID). */
 export declare function packetID(flow: string, k: number): string;
+/** `cost` as routing uses it: 1 for null, kept within 0...1,000,000 (ConnectorData.routeCost). */
+export declare const routeCost: (cost: number | null) => number;
 /** Every shape traffic from `from` can reach in `frame`, with the cheapest way to each:
  * by the connectors' cost (1 each unless set), ties to the shape reached first, earlier connectors first.
  * With `until`, the search stops once that shape is settled: its way is final then, and it is the first goal of any

package/dist/types/index.d.ts

@@ -5,7 +5,7 @@ export { BUNDLED_FONTS } from "./text.ts";
 export { inspect, inspectFrame, inspectPage, sampleTimes } from "./inspect.ts";
 export { DottiePlayer, Playback, definePlayer, pageIndex, withRoughness } from "./player.ts";
 export { bounds, plan, svg, svgParts, type Plan, type Part } from "./svg.ts";
-export { themeNamed, themes, type Theme } from "./theme.ts";
+export { pageTheme, paletteColor, themeNamed, themes, type Theme } from "./theme.ts";
 export { cameraView, frameTimes, posterTime, resolved, sceneAt, still, transientElements } from "./timeline.ts";
 export interface RenderOptions {
     /** Page name or 1-based number; the first page by default. */
@@ -20,4 +20,4 @@ export interface RenderOptions {
 /** One page of a drawing as an SVG document, as Dottie's own SVG export draws it. */
 export declare function render(source: string | DottieFile | unknown, options?: RenderOptions): string;
 /** The library's version. */
-export declare const VERSION = "0.9.0";
+export declare const VERSION = "0.10.0";

package/dist/types/measure.d.ts

@@ -28,6 +28,16 @@ export declare const emptyMetrics: () => FrameMetrics;
 export declare function metricValue(m: FrameMetrics, metric: string, id: string): number | null;
 /** A shape's delay as traffic feels it: 0...3600 seconds. */
 export declare function delayOf(e: Element): number;
+/** One way a flow's traffic takes in a frame (`flowFrame`'s routes): to `goal` over the connectors `hops`
+ * ([connector, backwards]), carrying `amount` of its volume at a cost of `cost`; `waits` when it goes only as far as
+ * the queue it waits in. */
+export interface FlowRoute {
+    goal: string;
+    hops: [string, boolean][];
+    amount: number;
+    waits: boolean;
+    cost: number;
+}
 /** The key of a flow's queue at a shape in `FrameMetrics.carry` and `carried` (DottieDocument.queueKey). */
 export declare const queueKey: (shape: string, flow: string) => string;
 /** The packets the page's flows draw in `frame` (the page posed at `t`), with these values (null: every flow runs),
@@ -37,6 +47,7 @@ export declare const queueKey: (shape: string, flow: string) => string;
 export declare function flowFrame(flows: Flow[] | null, frame: Page, t: number, values: Record<string, boolean> | null, offline?: Set<string>, sinceChange?: number | null, carried?: Record<string, number>): {
     packets: Element[];
     metrics: FrameMetrics;
+    routes: Map<string, FlowRoute[]>;
 };
 /** The frame's metric for a condition's comparison: its target an element's anchor, or an element's or flow's id. */
 export declare function metricLookup(m: FrameMetrics, frame: Page): (t: MetricTerm, own: string | null) => number | null;

package/dist/types/model.d.ts

@@ -29,6 +29,27 @@ export interface Style {
     dashOffset: number | null;
     /** The color of a shape's or connector's label; null follows `stroke`. Text boxes and notes ignore it. */
     textColor: RGBA | null;
+    /** Which colors are palette colors, by name (ADR 0005); set from the page's palette when it is read. */
+    named?: ColorNames | null;
+}
+/** Palette names for an element's colors (Theme.swift's ColorNames). */
+export interface ColorNames {
+    fill: string | null;
+    stroke: string | null;
+    textColor: string | null;
+}
+/** A named color in a theme's palette. */
+export interface PaletteColor {
+    name: string;
+    color: RGBA;
+}
+/** A theme made in the drawing (CustomTheme): it takes the place of the page's `theme`. */
+export interface CustomTheme {
+    name: string;
+    background: RGBA;
+    ink: RGBA;
+    palette: PaletteColor[];
+    base: string | null;
 }
 /** `portIndex` pins the end to one of the bound element's `ports`, and wins over `port`. */
 export interface Endpoint {
@@ -55,6 +76,8 @@ export interface ConnectorData {
     waypoints: StrokePoint[] | null;
     /** Hops where the line crosses a connector drawn beneath it. */
     hops: boolean | null;
+    /** An elbow line goes round the shapes in its way instead of through them (elbow.ts). */
+    avoid?: boolean | null;
     /** What a flow's traffic pays to take this connector (ADR 0002); null is 1. */
     cost: number | null;
 }
@@ -163,6 +186,13 @@ export interface Element {
     delay?: number | null;
     /** A shape that is a queue: backlog waits at the nearest one before whatever is full. */
     queue?: boolean | null;
+    /** The container this element is in (ADR 0006). */
+    containerID?: string | null;
+    /** On a rectangle: it's a container. Its title band is its `labelRect`, kept by the app, so drawing needs nothing more. */
+    container?: {
+        fixed: boolean | null;
+        lanes: "rows" | "columns" | null;
+    } | null;
     /** Shows a metric; drawn as plain paths and a label when the page is posed (metrics.ts). */
     gauge?: Gauge | null;
 }
@@ -250,6 +280,8 @@ export interface Page {
     layers: Layer[];
     elements: Element[];
     theme: string | null;
+    /** A theme of the page's own (ADR 0005), in place of `theme`. */
+    customTheme?: CustomTheme | null;
     timeline: Timeline | null;
     symbols: Symbol[] | null;
     /** The page's variables and their starting values (DottieDocument.variables). */

package/dist/types/theme.d.ts

@@ -1,10 +1,22 @@
-import type { RGBA } from "./model.ts";
+import type { Page, PaletteColor, RGBA } from "./model.ts";
 export interface Theme {
     id: string;
     name: string;
     background: RGBA;
     ink: RGBA;
+    palette: PaletteColor[];
 }
+/** The palette names every built-in theme has, in order. */
+export declare const PALETTE_NAMES: string[];
+/** Light pages. */
+export declare const LIGHT_PALETTE: PaletteColor[];
 export declare const themes: Theme[];
 /** The theme a page names, or null (white page, black ink) for none or one this version doesn't know. */
 export declare function themeNamed(id: string | null | undefined): Theme | null;
+/** The theme `page` is drawn in: its own, else the built-in it names, else null. */
+export declare function pageTheme(page: Pick<Page, "theme" | "customTheme">): Theme | null;
+/** The palette color `name` names on `page`, ignoring case. */
+export declare function paletteColor(page: Pick<Page, "theme" | "customTheme">, name: string): RGBA | null;
+/** `page` with every named color set from its palette (DottieDocument.resolvingPalette); a name the palette doesn't
+ * have keeps the color it had. */
+export declare function resolvingPalette(page: Page): Page;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phin-tech/dottie",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Render, play and compile Dottie (.dottie) drawings and animations in the browser",
   "type": "module",
   "license": "Apache-2.0",