@pixerate/editor 0.113.0 → 0.115.0

package/dist/{types-DtL_qLFz.d.ts → types-1SUQKDAw.d.ts}

@@ -30,6 +30,12 @@ interface VectorCorner {
     radius: number;
     /** Default `round`. */
     kind?: VectorCornerKind;
+    /**
+     * Corner smoothing (squircle, as in Figma and iOS), 0–1, round corners between straight sides
+     * only: the cut reaches (1 + smoothing) times as far along each side and eases into a shorter arc,
+     * so curvature builds up gradually. Default 0 (a circular arc).
+     */
+    smoothing?: number;
 }
 /**
  * One anchor of a subpath. Handles are absolute document positions; a missing (or `null`)
@@ -46,6 +52,12 @@ interface VectorAnchor {
     type?: VectorAnchorType;
     /** Live corner radius. Ignored on smooth / symmetric anchors and the ends of open subpaths. */
     corner?: VectorCorner | null;
+    /**
+     * A stable id, unique within its path, given when a constraint refers to the anchor (see
+     * `VectorConstraint`). Edits that move or restyle the anchor keep it; edits that rebuild a path
+     * drop it, and constraints on a dropped anchor are removed.
+     */
+    id?: string;
 }
 /** A chain of anchors joined by line or cubic Bézier segments. */
 interface VectorSubpath {
@@ -285,11 +297,76 @@ interface VectorNodeBase {
      * booleans ignore them.
      */
     filters?: VectorFilter[] | null;
+    /**
+     * How the node follows its frame when the frame is resized (`VectorGroupNode.frame`): per
+     * axis, pinned to the start (default `left` / `top`), the end, both (it stretches), the centre,
+     * or scaled with the frame. Ignored outside frames.
+     */
+    resizing?: VectorResizing | null;
+}
+/** Horizontal resizing constraint of a frame's child (see `VectorNodeBase.resizing`). */
+type VectorHorizontalResizing = 'left' | 'right' | 'leftRight' | 'center' | 'scale';
+/** Vertical resizing constraint of a frame's child (see `VectorNodeBase.resizing`). */
+type VectorVerticalResizing = 'top' | 'bottom' | 'topBottom' | 'center' | 'scale';
+declare const VECTOR_HORIZONTAL_RESIZING: readonly VectorHorizontalResizing[];
+declare const VECTOR_VERTICAL_RESIZING: readonly VectorVerticalResizing[];
+/** A frame child's resizing constraints (Figma's "constraints"). */
+interface VectorResizing {
+    /** Default `left`. */
+    horizontal?: VectorHorizontalResizing;
+    /** Default `top`. */
+    vertical?: VectorVerticalResizing;
+}
+/**
+ * Makes a group a frame (an artboard when top-level): a rectangle in the group's own space with an
+ * optional fill drawn below the children, which by default it clips. Resizing the frame moves and
+ * resizes its children by their `resizing` constraints instead of scaling them.
+ */
+interface VectorFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The frame's background, drawn below its children (default none). */
+    fill?: VectorPaint;
+    /** Clip the children to the frame (default true). */
+    clip?: boolean;
 }
 /** A shape made of one or more subpaths (holes and compound shapes included). */
 interface VectorPathNode extends VectorNodeBase, VectorStyle {
     type: 'path';
     subpaths: VectorSubpath[];
+    /**
+     * Makes the path a connector: an open line whose ends may be glued to other objects'
+     * connection sites. Its geometry is routed again after every edit, so it follows them.
+     */
+    connector?: VectorConnector | null;
+}
+/**
+ * Where a connector end meets an object: the middle of a side of the object's own (unrotated)
+ * bounds, its centre, or `auto` (the side facing the connector's other end, chosen on every route).
+ */
+type VectorConnectorSide = 'top' | 'right' | 'bottom' | 'left' | 'center' | 'auto';
+declare const VECTOR_CONNECTOR_SIDES: readonly VectorConnectorSide[];
+/** How a connector runs between its ends: a straight line, right-angled elbows or an S-curve. */
+type VectorConnectorRoute = 'straight' | 'elbow' | 'curved';
+declare const VECTOR_CONNECTOR_ROUTES: readonly VectorConnectorRoute[];
+/** A glued connector end. */
+interface VectorConnectorEnd {
+    nodeId: string;
+    /** Default `auto`. */
+    side?: VectorConnectorSide;
+}
+/** A connector's settings (`VectorPathNode.connector`). An end that is not glued stays where it is. */
+interface VectorConnector {
+    start?: VectorConnectorEnd | null;
+    end?: VectorConnectorEnd | null;
+    /** Default `straight`. */
+    route?: VectorConnectorRoute;
+    /** Corner radius of an elbow route's bends (document units, default 0). */
+    radius?: number;
+    /** How far an elbow or curve leaves a glued end straight out of its side before turning (document units, default 16). */
+    gap?: number;
 }
 /**
  * How a blend spaces its in-betweens: a number of `steps` between each pair of keys, a fixed
@@ -358,8 +435,145 @@ interface VectorGroupNode extends VectorNodeBase {
      * path effects to the contents (not the mask). Ignored on blends and live booleans.
      */
     mask?: VectorMask | null;
+    /**
+     * Makes the group a frame (see `VectorFrame`): it draws its fill below the children, clips them,
+     * selects and snaps by its rectangle, and lays its children out by their `resizing` constraints
+     * when resized. Ignored on blends, live booleans and mask groups.
+     */
+    frame?: VectorFrame | null;
+}
+/**
+ * The character style of text (a font and how it is set). Sizes are document units; `tracking` is in
+ * 1/1000 em. Paint comes from the node's fills and strokes (and a run's own `fill`).
+ */
+interface VectorCharacterStyle {
+    /** Family name ("Inter"); a family the shaper lacks draws in a fallback and is listed as missing. */
+    fontFamily: string;
+    /** CSS weight, 1–1000 (400 regular, 700 bold). */
+    fontWeight: number;
+    /** Default false. */
+    italic?: boolean;
+    fontSize: number;
+    /** Letter spacing in 1/1000 em (default 0). */
+    tracking?: number;
+    /** Baseline-to-baseline distance; absent: auto (`autoLeading` × size). */
+    leading?: number;
+    /** Raises (positive) or lowers the text (default 0). */
+    baselineShift?: number;
+    underline?: boolean;
+    strikethrough?: boolean;
+}
+/** Character style fields a run can set over the node's own style, plus its own fill. */
+type VectorTextRunStyle = Partial<VectorCharacterStyle> & {
+    /** The run's fill: replaces the paint of the node's top fill for these characters. */
+    fill?: VectorPaint;
+};
+/** A style over `length` UTF-16 code units of the text, in order. */
+interface VectorTextRun {
+    length: number;
+    style: VectorTextRunStyle;
+}
+type VectorTextAlign = 'left' | 'center' | 'right' | 'justify';
+declare const VECTOR_TEXT_ALIGNS: readonly VectorTextAlign[];
+/** Paragraph settings of a text node (all its paragraphs). Lengths in document units. */
+interface VectorParagraphStyle {
+    /** Default `left`. `justify` stretches every line of area text but a paragraph's last; on a path it spreads the text over the path. */
+    align?: VectorTextAlign;
+    /** Auto leading as a multiple of the font size (default 1.2). */
+    autoLeading?: number;
+    firstLineIndent?: number;
+    startIndent?: number;
+    endIndent?: number;
+    spaceBefore?: number;
+    spaceAfter?: number;
+}
+/** Where text on a path sits across the path: its baseline, ascender, descender or centre on the line. */
+type VectorPathTextBaseline = 'baseline' | 'ascender' | 'descender' | 'center';
+declare const VECTOR_PATH_TEXT_BASELINES: readonly VectorPathTextBaseline[];
+/**
+ * Where a text node's text goes, in the node's own space:
+ * - `point`: one line per paragraph, the first baseline starting at (`x`, `y`);
+ * - `area`: lines wrapped inside the box at (`x`, `y`) of `width` × `height` (lines that do not fit
+ *   are hidden: the text overflows);
+ * - `path`: one line set along `path` (paragraph breaks become spaces), from `start` to `end`
+ *   (distances from the path's ends), turned with the path (`orientation: 'rotate'`) or upright.
+ *   `flip` runs the text the other way, on the other side.
+ */
+type VectorTextFrame = {
+    kind: 'point';
+    x: number;
+    y: number;
+} | {
+    kind: 'area';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'path';
+    path: VectorSubpath;
+    /** Margin from the path's start (default 0). */
+    start?: number;
+    /** Margin from the path's end (default 0). */
+    end?: number;
+    flip?: boolean;
+    /** Default `rotate`. */
+    orientation?: 'rotate' | 'upright';
+    /** Default `baseline`. */
+    baseline?: VectorPathTextBaseline;
+};
+/**
+ * Text: a string with a character style, optional styled runs and a paragraph style, set in a
+ * frame. It paints with the node's fills and strokes like a path. Layout and glyphs come from the
+ * editor's text shaper (`setVectorTextShaper`); with an outline shaper the text draws as glyph
+ * outlines (so path effects, envelopes, booleans and Create Outlines work), otherwise as SVG text.
+ */
+interface VectorTextNode extends VectorNodeBase, VectorStyle {
+    type: 'text';
+    text: string;
+    /** The base character style. */
+    font: VectorCharacterStyle;
+    /** Runs over the text, each overriding some fields of `font` (absent: one style throughout). */
+    runs?: VectorTextRun[] | null;
+    paragraph?: VectorParagraphStyle | null;
+    frame: VectorTextFrame;
+}
+/**
+ * Per-instance changes to a symbol's art: every fill and / or stroke of the art painted with one
+ * paint (a tint), and art nodes (by their id in the symbol) hidden.
+ */
+interface VectorInstanceOverrides {
+    fill?: VectorPaint;
+    stroke?: VectorPaint;
+    /** Ids of nodes of the symbol's art (top-level or nested) not drawn in this instance. */
+    hidden?: string[];
+}
+/**
+ * A placed copy of a symbol (`VectorDocument.symbols`): it draws the symbol's art through its
+ * `transform`, which, unlike other nodes', may scale and skew. Editing the symbol changes every
+ * instance.
+ */
+interface VectorInstanceNode extends VectorNodeBase {
+    type: 'instance';
+    symbolId: string;
+    /** Strokes (and other lengths of the art's paint) scale with the instance (default true, as in Illustrator). */
+    scaleStrokes?: boolean;
+    overrides?: VectorInstanceOverrides | null;
+    /**
+     * The symbol's art, resolved by the editor (the same array as the symbol's `nodes`). Not part of
+     * the stored document: `VectorEditorController.toJSON` and SVG export leave it out, and loading
+     * resolves it again (`resolveVectorSymbols`).
+     */
+    art?: VectorNode[];
+}
+type VectorNode = VectorPathNode | VectorGroupNode | VectorTextNode | VectorInstanceNode;
+/** A symbol: reusable art its instances draw. */
+interface VectorSymbol {
+    id: string;
+    name: string;
+    /** The art, bottom to top, in the symbol's own space (its origin is the registration point instances are placed by). */
+    nodes: VectorNode[];
 }
-type VectorNode = VectorPathNode | VectorGroupNode;
 /** A vector drawing: an artboard and its nodes, bottom to top. */
 interface VectorDocument {
     width: number;
@@ -367,6 +581,58 @@ interface VectorDocument {
     /** Artboard colour (default: transparent). */
     background?: string;
     nodes: VectorNode[];
+    /** Symbols the document's instances draw (see `VectorInstanceNode`). */
+    symbols?: VectorSymbol[];
+    /** Constraints between anchors, segments and circles, solved after every edit. */
+    constraints?: VectorConstraint[];
+    /** Named values the constraints' expressions use. */
+    parameters?: VectorParameter[];
+}
+/**
+ * Constraint kinds (CAD-style parametric drawing). Geometric: `coincident` (two points, a point on
+ * a segment's line, or a point on a circle), `collinear` (two segments on one line), `concentric`
+ * (two circles, or a circle's centre on a point), `fix`, `parallel`, `perpendicular`, `horizontal`
+ * / `vertical` (a segment, or two points level), `tangent` (a segment and a circle, two circles, or
+ * G1 at an anchor: its handles in line), `smooth` (G2 at an anchor: G1 and equal curvature),
+ * `symmetric` (two points about a segment's line) and `equal` (segment lengths or radii).
+ * Dimensional (with a `value`): `distance`, `angle` (degrees), `radius` and `diameter`.
+ */
+type VectorConstraintKind = 'coincident' | 'collinear' | 'concentric' | 'fix' | 'parallel' | 'perpendicular' | 'horizontal' | 'vertical' | 'tangent' | 'smooth' | 'symmetric' | 'equal' | 'distance' | 'angle' | 'radius' | 'diameter';
+declare const VECTOR_CONSTRAINT_KINDS: readonly VectorConstraintKind[];
+/**
+ * What a constraint refers to: an anchor of a path (by its stable `id`), one of the anchor's
+ * handles, the segment from the anchor to the next one, or (no `anchor`) a whole path as a circle
+ * (its centre and radius, for closed round paths).
+ */
+interface VectorGeomRef {
+    nodeId: string;
+    /** The anchor's `id` (see `VectorAnchor.id`). */
+    anchor?: string;
+    /** With `anchor`: the handle instead of the anchor point. */
+    handle?: 'in' | 'out';
+    /** With `anchor`: the segment from it to the next anchor. */
+    segment?: boolean;
+    /** Without `anchor`: the path as a circle. */
+    circle?: boolean;
+}
+/** A constraint kept by the document and solved after every edit. */
+interface VectorConstraint {
+    id: string;
+    kind: VectorConstraintKind;
+    refs: VectorGeomRef[];
+    /** Dimensional constraints: the value as an expression (document units, degrees for angles), e.g. `"40"` or `"w / 2"`. */
+    value?: string;
+    /** Dimensional constraints: a name other expressions can use (`d1`, `ang2`). */
+    name?: string;
+    /** `distance`: measured along the line between (default), or only horizontally or vertically. */
+    axis?: 'aligned' | 'horizontal' | 'vertical';
+}
+/** A named value constraints' expressions can use. */
+interface VectorParameter {
+    name: string;
+    /** An expression (numbers, other names, `+ - * /`, parentheses, `pi`). */
+    value: string;
+    description?: string;
 }
 /** An axis-aligned rectangle. */
 interface VectorBounds {
@@ -393,9 +659,12 @@ interface VectorHandleRef extends VectorAnchorRef {
  * fills the region the visible outlines enclose around a click with a new shape. `blend`
  * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
  * starts the blend there). `envelope` edits the mesh of the selection's envelope: drag its
- * anchors and handles, or inside a patch to pull the surface.
+ * anchors and handles, or inside a patch to pull the surface. `type` adds point text (click) or
+ * area text (drag) and edits text it clicks; `typePath` sets text along the path it clicks. `frame`
+ * drags out a frame (`VectorGroupNode.frame`), taking in the top-level objects it fully encloses.
+ * `connector` drags a connector between objects, gluing each end to the side it starts or ends on.
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope' | 'type' | 'typePath' | 'frame' | 'connector';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -627,4 +896,4 @@ type VectorFilter = {
     };
 }[VectorFilterType];
 
-export { type VectorBlend as $, type VectorCornerKind as A, type VectorViewport as B, type VectorTransformHandle as C, type VectorAnchorRef as D, type VectorPathfinderOperation as E, type VectorTool as F, type VectorDefaults as G, type VectorStyle as H, type VectorHandleRef as I, type VectorSegmentRef as J, type VectorBlendOptions as K, type VectorModifiers as L, type VectorBlendMode as M, type VectorAlign as N, type VectorDistribute as O, type VectorArrange as P, type VectorMaskType as Q, type VectorMask as R, type VectorAverageAxis as S, type VectorArrowhead as T, type VectorBlendSpacing as U, type VectorEffectType as V, type VectorGradientInterpolation as W, type VectorStrokeGradientMode as X, type VectorArrowAlign as Y, type VectorPaintLayer as Z, type VectorStrokeLayer as _, type VectorEffectParamsMap as a, type VectorMergeMode as a0, type VectorLineJoin as a1, type VectorStrokeSettings as a2, VECTOR_ARROWHEADS as a3, VECTOR_BLEND_MODES as a4, VECTOR_BLEND_SPACINGS as a5, VECTOR_CORNER_KINDS as a6, VECTOR_EFFECT_TYPES as a7, VECTOR_FILTER_TYPES as a8, VECTOR_GRADIENT_INTERPOLATIONS as a9, VECTOR_GRADIENT_SPREADS as aa, VECTOR_GRADIENT_TYPES as ab, VECTOR_MASK_TYPES as ac, VECTOR_MERGE_MODES as ad, VECTOR_PATHFINDER_OPERATIONS as ae, VECTOR_STROKE_GRADIENT_MODES as af, VECTOR_TOOLS as ag, VECTOR_TRANSFORM_HANDLES as ah, type VectorCorner as ai, type VectorLineCap as aj, type VectorStrokeLayerKind as ak, type VectorWarpStyle as al, type VectorPathNode as b, type VectorFillRule as c, type VectorBooleanOperation as d, type VectorNode as e, type VectorEffect as f, type VectorGroupNode as g, type VectorBounds as h, type VectorWarpMesh as i, type VectorFilterType as j, type VectorFilterParamsMap as k, type VectorFilter as l, type VectorGradient as m, type Vec2 as n, type VectorGradientUnits as o, type VectorGradientSpread as p, type VectorGradientType as q, type VectorPaint as r, type VectorMatrix as s, type VectorGradientStop as t, type VectorStrokeAlign as u, type VectorSubpath as v, type VectorDocument as w, type VectorWidthPoint as x, type VectorAnchor as y, type VectorAnchorType as z };
+export { type VectorAlign as $, type VectorTextNode as A, type VectorAnchorType as B, type VectorCornerKind as C, type VectorViewport as D, type VectorConnectorRoute as E, type VectorConnectorSide as F, type VectorConnectorEnd as G, type VectorConnector as H, type VectorConstraintKind as I, type VectorConstraint as J, type VectorCharacterStyle as K, type VectorTextRun as L, type VectorParagraphStyle as M, type VectorTextFrame as N, type VectorTransformHandle as O, type VectorAnchorRef as P, type VectorPathfinderOperation as Q, type VectorTool as R, type VectorDefaults as S, type VectorTextAlign as T, type VectorStyle as U, type VectorEffectType as V, type VectorHandleRef as W, type VectorSegmentRef as X, type VectorBlendOptions as Y, type VectorModifiers as Z, type VectorBlendMode as _, type VectorEffectParamsMap as a, type VectorDistribute as a0, type VectorArrange as a1, type VectorMaskType as a2, type VectorArrowhead as a3, type VectorResizing as a4, type VectorFrame as a5, type VectorHorizontalResizing as a6, type VectorVerticalResizing as a7, type VectorMask as a8, type VectorAverageAxis as a9, VECTOR_MASK_TYPES as aA, VECTOR_MERGE_MODES as aB, VECTOR_PATHFINDER_OPERATIONS as aC, VECTOR_PATH_TEXT_BASELINES as aD, VECTOR_STROKE_GRADIENT_MODES as aE, VECTOR_TEXT_ALIGNS as aF, VECTOR_TOOLS as aG, VECTOR_TRANSFORM_HANDLES as aH, VECTOR_VERTICAL_RESIZING as aI, type VectorCorner as aJ, type VectorGeomRef as aK, type VectorLineCap as aL, type VectorPathTextBaseline as aM, type VectorStrokeLayerKind as aN, type VectorTextRunStyle as aO, type VectorWarpStyle as aP, type VectorSymbol as aa, type VectorParameter as ab, type VectorBlendSpacing as ac, type VectorGradientInterpolation as ad, type VectorStrokeGradientMode as ae, type VectorArrowAlign as af, type VectorPaintLayer as ag, type VectorStrokeLayer as ah, type VectorBlend as ai, type VectorMergeMode as aj, type VectorLineJoin as ak, type VectorStrokeSettings as al, type VectorInstanceOverrides as am, VECTOR_ARROWHEADS as an, VECTOR_BLEND_MODES as ao, VECTOR_BLEND_SPACINGS as ap, VECTOR_CONNECTOR_ROUTES as aq, VECTOR_CONNECTOR_SIDES as ar, VECTOR_CONSTRAINT_KINDS as as, VECTOR_CORNER_KINDS as at, VECTOR_EFFECT_TYPES as au, VECTOR_FILTER_TYPES as av, VECTOR_GRADIENT_INTERPOLATIONS as aw, VECTOR_GRADIENT_SPREADS as ax, VECTOR_GRADIENT_TYPES as ay, VECTOR_HORIZONTAL_RESIZING as az, type VectorPathNode as b, type VectorFillRule as c, type VectorBooleanOperation as d, type VectorNode as e, type VectorEffect as f, type VectorGroupNode as g, type VectorBounds as h, type VectorWarpMesh as i, type VectorInstanceNode as j, type VectorFilterType as k, type VectorFilterParamsMap as l, type VectorFilter as m, type VectorGradient as n, type Vec2 as o, type VectorGradientUnits as p, type VectorGradientSpread as q, type VectorGradientType as r, type VectorPaint as s, type VectorMatrix as t, type VectorGradientStop as u, type VectorStrokeAlign as v, type VectorSubpath as w, type VectorDocument as x, type VectorWidthPoint as y, type VectorAnchor as z };