@pibbl/core 0.0.1

package/dist/lib/focus/types.d.ts

@@ -0,0 +1,37 @@
+import type { KeyboardNavigation, KeyboardNavigationProps } from "./policy-components.js";
+import type { PibblEventTargetRegistration } from "../events/registrations.js";
+import type { LayoutBox } from "../layout/types.js";
+import type { HtmlFocusRegion } from "./html-focus-region.js";
+export type PibblFocusModality = "keyboard" | "pointer";
+/**
+ * Directional keyboard-navigation policy for a focus scope.
+ *
+ * @see {@link KeyboardNavigation}
+ * @see {@link KeyboardNavigationProps}
+ */
+export interface PibblKeyboardNavigationOptions {
+    /**
+     * Selects the supported mapping, placement, or result policy. See
+     * {@link PibblKeyboardNavigationOptions}.
+     */
+    readonly mode: "directional";
+}
+export interface PibblDirectionalBoundary {
+    readonly candidates: readonly PibblNavigationCandidate[];
+}
+export interface PibblFocusCandidate {
+    readonly target: PibblEventTargetRegistration;
+    readonly sourceIndex: number;
+    readonly directionalBoundary: PibblDirectionalBoundary | undefined;
+    readonly rootBounds: Readonly<LayoutBox> | undefined;
+}
+/** @internal A native HtmlBox region participating in the same Pibbl order. */
+export interface PibblHtmlFocusCandidate {
+    readonly region: HtmlFocusRegion;
+    readonly sourceIndex: number;
+    readonly directionalBoundary: PibblDirectionalBoundary | undefined;
+    readonly rootBounds: Readonly<LayoutBox> | undefined;
+}
+/** @internal Shared geometry/navigation representation; Canvas events stay Canvas-only. */
+export type PibblNavigationCandidate = PibblFocusCandidate | PibblHtmlFocusCandidate;
+export declare function isHtmlFocusCandidate(candidate: PibblNavigationCandidate): candidate is PibblHtmlFocusCandidate;

package/dist/lib/focus/types.js

@@ -0,0 +1,7 @@
+function isHtmlFocusCandidate(candidate) {
+  return "region" in candidate;
+}
+export {
+  isHtmlFocusCandidate
+};
+//# sourceMappingURL=types.js.map

package/dist/lib/focus/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/focus/types.ts"],
+  "sourcesContent": ["import type { KeyboardNavigation, KeyboardNavigationProps } from './policy-components.js';\nimport type { PibblEventTargetRegistration } from \"../events/registrations.js\";\nimport type { LayoutBox } from \"../layout/types.js\";\nimport type { HtmlFocusRegion } from \"./html-focus-region.js\";\n\nexport type PibblFocusModality = \"keyboard\" | \"pointer\";\n\n/**\n * Directional keyboard-navigation policy for a focus scope.\n *\n * @see {@link KeyboardNavigation}\n * @see {@link KeyboardNavigationProps}\n */\nexport interface PibblKeyboardNavigationOptions {\n  /**\n   * Selects the supported mapping, placement, or result policy. See\n   * {@link PibblKeyboardNavigationOptions}.\n   */\n  readonly mode: \"directional\";\n}\n\nexport interface PibblDirectionalBoundary {\n  readonly candidates: readonly PibblNavigationCandidate[];\n}\n\nexport interface PibblFocusCandidate {\n  readonly target: PibblEventTargetRegistration;\n  readonly sourceIndex: number;\n  readonly directionalBoundary: PibblDirectionalBoundary | undefined;\n  readonly rootBounds: Readonly<LayoutBox> | undefined;\n}\n\n/** @internal A native HtmlBox region participating in the same Pibbl order. */\nexport interface PibblHtmlFocusCandidate {\n  readonly region: HtmlFocusRegion;\n  readonly sourceIndex: number;\n  readonly directionalBoundary: PibblDirectionalBoundary | undefined;\n  readonly rootBounds: Readonly<LayoutBox> | undefined;\n}\n\n/** @internal Shared geometry/navigation representation; Canvas events stay Canvas-only. */\nexport type PibblNavigationCandidate = PibblFocusCandidate | PibblHtmlFocusCandidate;\n\nexport function isHtmlFocusCandidate(\n  candidate: PibblNavigationCandidate,\n): candidate is PibblHtmlFocusCandidate {\n  return \"region\" in candidate;\n}\n"],
+  "mappings": "AA2CO,SAAS,qBACd,WACsC;AACtC,SAAO,YAAY;AACrB;",
+  "names": []
+}

package/dist/lib/geometry/circle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Geometry and construction options for a circle path.
+ *
+ * @see {@link createCirclePath}
+ */
+export interface CirclePathOptions {
+    /** Horizontal coordinate of the center. See {@link CirclePathOptions}. */
+    cx?: number;
+    /** Vertical coordinate of the center. See {@link CirclePathOptions}. */
+    cy?: number;
+    /** Radius in the coordinate system of this geometry or effect. See {@link CirclePathOptions}. */
+    radius: number;
+}
+/**
+ * Creates a Canvas Path2D for circle geometry from validated options.
+ *
+ * @param options - Circle center and radius. See {@link CirclePathOptions}.
+ * @returns A native Canvas path containing the circle.
+ *
+ * @see {@link CirclePathOptions}
+ */
+export declare function createCirclePath(options: Readonly<CirclePathOptions>): Path2D;

package/dist/lib/geometry/circle.js

@@ -0,0 +1,13 @@
+import { finiteNumber, nonnegativeNumber } from "./validation.js";
+function createCirclePath(options) {
+  const cx = finiteNumber(options.cx ?? 0, "cx");
+  const cy = finiteNumber(options.cy ?? 0, "cy");
+  const radius = nonnegativeNumber(options.radius, "radius");
+  const path = new Path2D();
+  if (radius > 0) path.arc(cx, cy, radius, 0, Math.PI * 2);
+  return path;
+}
+export {
+  createCirclePath
+};
+//# sourceMappingURL=circle.js.map

package/dist/lib/geometry/circle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/circle.ts"],
+  "sourcesContent": ["import { finiteNumber, nonnegativeNumber } from './validation.js';\n\n/**\n * Geometry and construction options for a circle path.\n *\n * @see {@link createCirclePath}\n */\nexport interface CirclePathOptions {\n  /** Horizontal coordinate of the center. See {@link CirclePathOptions}. */\n  cx?: number;\n  /** Vertical coordinate of the center. See {@link CirclePathOptions}. */\n  cy?: number;\n  /** Radius in the coordinate system of this geometry or effect. See {@link CirclePathOptions}. */\n  radius: number;\n}\n\n/**\n * Creates a Canvas Path2D for circle geometry from validated options.\n *\n * @param options - Circle center and radius. See {@link CirclePathOptions}.\n * @returns A native Canvas path containing the circle.\n *\n * @see {@link CirclePathOptions}\n */\nexport function createCirclePath(options: Readonly<CirclePathOptions>): Path2D {\n  const cx = finiteNumber(options.cx ?? 0, 'cx');\n  const cy = finiteNumber(options.cy ?? 0, 'cy');\n  const radius = nonnegativeNumber(options.radius, 'radius');\n  const path = new Path2D();\n  if (radius > 0) path.arc(cx, cy, radius, 0, Math.PI * 2);\n  return path;\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc,yBAAyB;AAwBzC,SAAS,iBAAiB,SAA8C;AAC7E,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,IAAI;AAC7C,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,IAAI;AAC7C,QAAM,SAAS,kBAAkB,QAAQ,QAAQ,QAAQ;AACzD,QAAM,OAAO,IAAI,OAAO;AACxB,MAAI,SAAS,EAAG,MAAK,IAAI,IAAI,IAAI,QAAQ,GAAG,KAAK,KAAK,CAAC;AACvD,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/geometry/circular-sweep.d.ts

@@ -0,0 +1,54 @@
+export interface CircularSweep {
+    readonly startAngle: number;
+    readonly endAngle: number;
+    readonly sweep: number;
+    readonly counterclockwise: boolean;
+    readonly fullCircle: boolean;
+}
+/**
+ * Geometry and construction options for a arc path.
+ *
+ * @see {@link createArcPath}
+ * @see {@link WedgePathOptions}
+ */
+export interface ArcPathOptions {
+    /** Horizontal coordinate of the center. See {@link ArcPathOptions}. */
+    cx?: number;
+    /** Vertical coordinate of the center. See {@link ArcPathOptions}. */
+    cy?: number;
+    /** Radius in the coordinate system of this geometry or effect. See {@link ArcPathOptions}. */
+    radius: number;
+    /** Angle at which the arc or slice begins. See {@link ArcPathOptions}. */
+    startAngle: number;
+    /** Angle at which the arc or slice ends. See {@link ArcPathOptions}. */
+    endAngle: number;
+    /** Whether the arc follows the counterclockwise direction. See {@link ArcPathOptions}. */
+    counterclockwise?: boolean;
+}
+/**
+ * Geometry and construction options for a wedge path.
+ *
+ * @see {@link ArcPathOptions}
+ * @see {@link createWedgePath}
+ */
+export type WedgePathOptions = ArcPathOptions;
+export declare function resolveCircularSweep(startAngle: number, endAngle: number, counterclockwise: boolean): CircularSweep;
+/**
+ * Creates a Canvas Path2D for arc geometry from validated options.
+ *
+ * @param options - Circle center, radius, angles, and sweep direction. See {@link ArcPathOptions}.
+ * @returns A native Canvas path containing the arc.
+ *
+ * @see {@link ArcPathOptions}
+ */
+export declare function createArcPath(options: Readonly<ArcPathOptions>): Path2D;
+/**
+ * Creates a Canvas Path2D for wedge geometry from validated options.
+ *
+ * @param options - Circle center, radius, angles, and sweep direction. See
+ * {@link WedgePathOptions} .
+ * @returns A native Canvas path containing the closed wedge.
+ *
+ * @see {@link WedgePathOptions}
+ */
+export declare function createWedgePath(options: Readonly<WedgePathOptions>): Path2D;

package/dist/lib/geometry/circular-sweep.js

@@ -0,0 +1,95 @@
+import { finiteNumber, nonnegativeNumber } from "./validation.js";
+const fullTurn = Math.PI * 2;
+function resolveCircularSweep(startAngle, endAngle, counterclockwise) {
+  const fullCircle = counterclockwise ? startAngle - endAngle >= fullTurn : endAngle - startAngle >= fullTurn;
+  let sweep;
+  if (fullCircle) {
+    sweep = counterclockwise ? -fullTurn : fullTurn;
+  } else if (counterclockwise) {
+    const distance = positiveModulo(startAngle - endAngle, fullTurn);
+    sweep = distance === 0 ? 0 : -distance;
+  } else {
+    sweep = positiveModulo(endAngle - startAngle, fullTurn);
+  }
+  return {
+    startAngle,
+    endAngle: startAngle + sweep,
+    sweep,
+    counterclockwise,
+    fullCircle
+  };
+}
+function createArcPath(options) {
+  const normalized = validateArcOptions(options);
+  const sweep = resolveCircularSweep(
+    normalized.startAngle,
+    normalized.endAngle,
+    normalized.counterclockwise
+  );
+  return buildArcPath(normalized.cx, normalized.cy, normalized.radius, sweep);
+}
+function createWedgePath(options) {
+  const normalized = validateArcOptions(options);
+  const sweep = resolveCircularSweep(
+    normalized.startAngle,
+    normalized.endAngle,
+    normalized.counterclockwise
+  );
+  return buildWedgePath(normalized.cx, normalized.cy, normalized.radius, sweep);
+}
+function buildArcPath(cx, cy, radius, sweep) {
+  const path = new Path2D();
+  if (radius > 0 && sweep.sweep !== 0) {
+    path.arc(
+      cx,
+      cy,
+      radius,
+      sweep.startAngle,
+      sweep.endAngle,
+      sweep.counterclockwise
+    );
+  }
+  return path;
+}
+function buildWedgePath(cx, cy, radius, sweep) {
+  const path = new Path2D();
+  if (radius <= 0 || sweep.sweep === 0) return path;
+  if (!sweep.fullCircle) {
+    path.moveTo(cx, cy);
+    path.lineTo(
+      cx + radius * Math.cos(sweep.startAngle),
+      cy + radius * Math.sin(sweep.startAngle)
+    );
+  }
+  path.arc(
+    cx,
+    cy,
+    radius,
+    sweep.startAngle,
+    sweep.endAngle,
+    sweep.counterclockwise
+  );
+  path.closePath();
+  return path;
+}
+function validateArcOptions(options) {
+  return {
+    cx: finiteNumber(options.cx ?? 0, "cx"),
+    cy: finiteNumber(options.cy ?? 0, "cy"),
+    radius: nonnegativeNumber(options.radius, "radius"),
+    startAngle: finiteNumber(options.startAngle, "startAngle"),
+    endAngle: finiteNumber(options.endAngle, "endAngle"),
+    counterclockwise: options.counterclockwise ?? false
+  };
+}
+function positiveModulo(value, divisor) {
+  const result = value % divisor;
+  if (result === 0) return 0;
+  return result < 0 ? result + divisor : result;
+}
+export {
+  createArcPath,
+  createWedgePath,
+  resolveCircularSweep
+};
+//# sourceMappingURL=circular-sweep.js.map

package/dist/lib/geometry/circular-sweep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/circular-sweep.ts"],
+  "sourcesContent": ["import { finiteNumber, nonnegativeNumber } from \"./validation.js\";\n\nconst fullTurn = Math.PI * 2;\n\nexport interface CircularSweep {\n  readonly startAngle: number;\n  readonly endAngle: number;\n  readonly sweep: number;\n  readonly counterclockwise: boolean;\n  readonly fullCircle: boolean;\n}\n\n/**\n * Geometry and construction options for a arc path.\n *\n * @see {@link createArcPath}\n * @see {@link WedgePathOptions}\n */\nexport interface ArcPathOptions {\n  /** Horizontal coordinate of the center. See {@link ArcPathOptions}. */\n  cx?: number;\n  /** Vertical coordinate of the center. See {@link ArcPathOptions}. */\n  cy?: number;\n  /** Radius in the coordinate system of this geometry or effect. See {@link ArcPathOptions}. */\n  radius: number;\n  /** Angle at which the arc or slice begins. See {@link ArcPathOptions}. */\n  startAngle: number;\n  /** Angle at which the arc or slice ends. See {@link ArcPathOptions}. */\n  endAngle: number;\n  /** Whether the arc follows the counterclockwise direction. See {@link ArcPathOptions}. */\n  counterclockwise?: boolean;\n}\n\n/**\n * Geometry and construction options for a wedge path.\n *\n * @see {@link ArcPathOptions}\n * @see {@link createWedgePath}\n */\nexport type WedgePathOptions = ArcPathOptions;\n\nexport function resolveCircularSweep(\n  startAngle: number,\n  endAngle: number,\n  counterclockwise: boolean,\n): CircularSweep {\n  const fullCircle = counterclockwise\n    ? startAngle - endAngle >= fullTurn\n    : endAngle - startAngle >= fullTurn;\n  let sweep: number;\n  if (fullCircle) {\n    sweep = counterclockwise ? -fullTurn : fullTurn;\n  } else if (counterclockwise) {\n    const distance = positiveModulo(startAngle - endAngle, fullTurn);\n    sweep = distance === 0 ? 0 : -distance;\n  } else {\n    sweep = positiveModulo(endAngle - startAngle, fullTurn);\n  }\n\n  return {\n    startAngle,\n    endAngle: startAngle + sweep,\n    sweep,\n    counterclockwise,\n    fullCircle,\n  };\n}\n\n/**\n * Creates a Canvas Path2D for arc geometry from validated options.\n *\n * @param options - Circle center, radius, angles, and sweep direction. See {@link ArcPathOptions}.\n * @returns A native Canvas path containing the arc.\n *\n * @see {@link ArcPathOptions}\n */\nexport function createArcPath(options: Readonly<ArcPathOptions>): Path2D {\n  const normalized = validateArcOptions(options);\n  const sweep = resolveCircularSweep(\n    normalized.startAngle,\n    normalized.endAngle,\n    normalized.counterclockwise,\n  );\n  return buildArcPath(normalized.cx, normalized.cy, normalized.radius, sweep);\n}\n\n/**\n * Creates a Canvas Path2D for wedge geometry from validated options.\n *\n * @param options - Circle center, radius, angles, and sweep direction. See\n * {@link WedgePathOptions} .\n * @returns A native Canvas path containing the closed wedge.\n *\n * @see {@link WedgePathOptions}\n */\nexport function createWedgePath(options: Readonly<WedgePathOptions>): Path2D {\n  const normalized = validateArcOptions(options);\n  const sweep = resolveCircularSweep(\n    normalized.startAngle,\n    normalized.endAngle,\n    normalized.counterclockwise,\n  );\n  return buildWedgePath(normalized.cx, normalized.cy, normalized.radius, sweep);\n}\n\nfunction buildArcPath(\n  cx: number,\n  cy: number,\n  radius: number,\n  sweep: Readonly<CircularSweep>,\n): Path2D {\n  const path = new Path2D();\n  if (radius > 0 && sweep.sweep !== 0) {\n    path.arc(\n      cx,\n      cy,\n      radius,\n      sweep.startAngle,\n      sweep.endAngle,\n      sweep.counterclockwise,\n    );\n  }\n  return path;\n}\n\nfunction buildWedgePath(\n  cx: number,\n  cy: number,\n  radius: number,\n  sweep: Readonly<CircularSweep>,\n): Path2D {\n  const path = new Path2D();\n  if (radius <= 0 || sweep.sweep === 0) return path;\n\n  if (!sweep.fullCircle) {\n    path.moveTo(cx, cy);\n    path.lineTo(\n      cx + radius * Math.cos(sweep.startAngle),\n      cy + radius * Math.sin(sweep.startAngle),\n    );\n  }\n  path.arc(\n    cx,\n    cy,\n    radius,\n    sweep.startAngle,\n    sweep.endAngle,\n    sweep.counterclockwise,\n  );\n  path.closePath();\n  return path;\n}\n\nfunction validateArcOptions(options: Readonly<ArcPathOptions>): {\n  cx: number;\n  cy: number;\n  radius: number;\n  startAngle: number;\n  endAngle: number;\n  counterclockwise: boolean;\n} {\n  return {\n    cx: finiteNumber(options.cx ?? 0, \"cx\"),\n    cy: finiteNumber(options.cy ?? 0, \"cy\"),\n    radius: nonnegativeNumber(options.radius, \"radius\"),\n    startAngle: finiteNumber(options.startAngle, \"startAngle\"),\n    endAngle: finiteNumber(options.endAngle, \"endAngle\"),\n    counterclockwise: options.counterclockwise ?? false,\n  };\n}\n\nfunction positiveModulo(value: number, divisor: number): number {\n  const result = value % divisor;\n  if (result === 0) return 0;\n  return result < 0 ? result + divisor : result;\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc,yBAAyB;AAEhD,MAAM,WAAW,KAAK,KAAK;AAuCpB,SAAS,qBACd,YACA,UACA,kBACe;AACf,QAAM,aAAa,mBACf,aAAa,YAAY,WACzB,WAAW,cAAc;AAC7B,MAAI;AACJ,MAAI,YAAY;AACd,YAAQ,mBAAmB,CAAC,WAAW;AAAA,EACzC,WAAW,kBAAkB;AAC3B,UAAM,WAAW,eAAe,aAAa,UAAU,QAAQ;AAC/D,YAAQ,aAAa,IAAI,IAAI,CAAC;AAAA,EAChC,OAAO;AACL,YAAQ,eAAe,WAAW,YAAY,QAAQ;AAAA,EACxD;AAEA,SAAO;AAAA,IACL;AAAA,IACA,UAAU,aAAa;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAUO,SAAS,cAAc,SAA2C;AACvE,QAAM,aAAa,mBAAmB,OAAO;AAC7C,QAAM,QAAQ;AAAA,IACZ,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,EACb;AACA,SAAO,aAAa,WAAW,IAAI,WAAW,IAAI,WAAW,QAAQ,KAAK;AAC5E;AAWO,SAAS,gBAAgB,SAA6C;AAC3E,QAAM,aAAa,mBAAmB,OAAO;AAC7C,QAAM,QAAQ;AAAA,IACZ,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,EACb;AACA,SAAO,eAAe,WAAW,IAAI,WAAW,IAAI,WAAW,QAAQ,KAAK;AAC9E;AAEA,SAAS,aACP,IACA,IACA,QACA,OACQ;AACR,QAAM,OAAO,IAAI,OAAO;AACxB,MAAI,SAAS,KAAK,MAAM,UAAU,GAAG;AACnC,SAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,eACP,IACA,IACA,QACA,OACQ;AACR,QAAM,OAAO,IAAI,OAAO;AACxB,MAAI,UAAU,KAAK,MAAM,UAAU,EAAG,QAAO;AAE7C,MAAI,CAAC,MAAM,YAAY;AACrB,SAAK,OAAO,IAAI,EAAE;AAClB,SAAK;AAAA,MACH,KAAK,SAAS,KAAK,IAAI,MAAM,UAAU;AAAA,MACvC,KAAK,SAAS,KAAK,IAAI,MAAM,UAAU;AAAA,IACzC;AAAA,EACF;AACA,OAAK;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,EACR;AACA,OAAK,UAAU;AACf,SAAO;AACT;AAEA,SAAS,mBAAmB,SAO1B;AACA,SAAO;AAAA,IACL,IAAI,aAAa,QAAQ,MAAM,GAAG,IAAI;AAAA,IACtC,IAAI,aAAa,QAAQ,MAAM,GAAG,IAAI;AAAA,IACtC,QAAQ,kBAAkB,QAAQ,QAAQ,QAAQ;AAAA,IAClD,YAAY,aAAa,QAAQ,YAAY,YAAY;AAAA,IACzD,UAAU,aAAa,QAAQ,UAAU,UAAU;AAAA,IACnD,kBAAkB,QAAQ,oBAAoB;AAAA,EAChD;AACF;AAEA,SAAS,eAAe,OAAe,SAAyB;AAC9D,QAAM,SAAS,QAAQ;AACvB,MAAI,WAAW,EAAG,QAAO;AACzB,SAAO,SAAS,IAAI,SAAS,UAAU;AACzC;",
+  "names": []
+}

package/dist/lib/geometry/ellipse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Geometry and construction options for a ellipse path.
+ *
+ * @see {@link createEllipsePath}
+ */
+export interface EllipsePathOptions {
+    /** Horizontal coordinate of the center. See {@link EllipsePathOptions}. */
+    cx?: number;
+    /** Vertical coordinate of the center. See {@link EllipsePathOptions}. */
+    cy?: number;
+    /** Horizontal ellipse radius. See {@link EllipsePathOptions}. */
+    radiusX: number;
+    /** Vertical ellipse radius. See {@link EllipsePathOptions}. */
+    radiusY: number;
+    /** Rotation applied to the containing geometry. See {@link EllipsePathOptions}. */
+    rotation?: number;
+}
+/**
+ * Creates a Canvas Path2D for ellipse geometry from validated options.
+ *
+ * @param options - Ellipse center, radii, and rotation. See {@link EllipsePathOptions}.
+ * @returns A native Canvas path containing the ellipse.
+ *
+ * @see {@link EllipsePathOptions}
+ */
+export declare function createEllipsePath(options: Readonly<EllipsePathOptions>): Path2D;

package/dist/lib/geometry/ellipse.js

@@ -0,0 +1,17 @@
+import { finiteNumber, nonnegativeNumber } from "./validation.js";
+function createEllipsePath(options) {
+  const cx = finiteNumber(options.cx ?? 0, "cx");
+  const cy = finiteNumber(options.cy ?? 0, "cy");
+  const radiusX = nonnegativeNumber(options.radiusX, "radiusX");
+  const radiusY = nonnegativeNumber(options.radiusY, "radiusY");
+  const rotation = finiteNumber(options.rotation ?? 0, "rotation");
+  const path = new Path2D();
+  if (radiusX > 0 && radiusY > 0) {
+    path.ellipse(cx, cy, radiusX, radiusY, rotation, 0, Math.PI * 2);
+  }
+  return path;
+}
+export {
+  createEllipsePath
+};
+//# sourceMappingURL=ellipse.js.map

package/dist/lib/geometry/ellipse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/ellipse.ts"],
+  "sourcesContent": ["import { finiteNumber, nonnegativeNumber } from './validation.js';\n\n/**\n * Geometry and construction options for a ellipse path.\n *\n * @see {@link createEllipsePath}\n */\nexport interface EllipsePathOptions {\n  /** Horizontal coordinate of the center. See {@link EllipsePathOptions}. */\n  cx?: number;\n  /** Vertical coordinate of the center. See {@link EllipsePathOptions}. */\n  cy?: number;\n  /** Horizontal ellipse radius. See {@link EllipsePathOptions}. */\n  radiusX: number;\n  /** Vertical ellipse radius. See {@link EllipsePathOptions}. */\n  radiusY: number;\n  /** Rotation applied to the containing geometry. See {@link EllipsePathOptions}. */\n  rotation?: number;\n}\n\n/**\n * Creates a Canvas Path2D for ellipse geometry from validated options.\n *\n * @param options - Ellipse center, radii, and rotation. See {@link EllipsePathOptions}.\n * @returns A native Canvas path containing the ellipse.\n *\n * @see {@link EllipsePathOptions}\n */\nexport function createEllipsePath(options: Readonly<EllipsePathOptions>): Path2D {\n  const cx = finiteNumber(options.cx ?? 0, 'cx');\n  const cy = finiteNumber(options.cy ?? 0, 'cy');\n  const radiusX = nonnegativeNumber(options.radiusX, 'radiusX');\n  const radiusY = nonnegativeNumber(options.radiusY, 'radiusY');\n  const rotation = finiteNumber(options.rotation ?? 0, 'rotation');\n  const path = new Path2D();\n  if (radiusX > 0 && radiusY > 0) {\n    path.ellipse(cx, cy, radiusX, radiusY, rotation, 0, Math.PI * 2);\n  }\n  return path;\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc,yBAAyB;AA4BzC,SAAS,kBAAkB,SAA+C;AAC/E,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,IAAI;AAC7C,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,IAAI;AAC7C,QAAM,UAAU,kBAAkB,QAAQ,SAAS,SAAS;AAC5D,QAAM,UAAU,kBAAkB,QAAQ,SAAS,SAAS;AAC5D,QAAM,WAAW,aAAa,QAAQ,YAAY,GAAG,UAAU;AAC/D,QAAM,OAAO,IAAI,OAAO;AACxB,MAAI,UAAU,KAAK,UAAU,GAAG;AAC9B,SAAK,QAAQ,IAAI,IAAI,SAAS,SAAS,UAAU,GAAG,KAAK,KAAK,CAAC;AAAA,EACjE;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/geometry/line.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Geometry and construction options for a line path.
+ *
+ * @see {@link createLinePath}
+ */
+export interface LinePathOptions {
+    /** Ordered coordinate pairs describing the path vertices. See {@link LinePathOptions}. */
+    coords: readonly (readonly [number, number])[];
+    /** Whether to connect the final vertex back to the first. See {@link LinePathOptions}. */
+    closePath?: boolean;
+}
+/**
+ * Creates a Canvas Path2D for line geometry from validated options.
+ *
+ * @param options - Ordered vertices and whether to close the path. See {@link LinePathOptions}.
+ * @returns A native Canvas path containing the line.
+ *
+ * @see {@link LinePathOptions}
+ */
+export declare function createLinePath(options: Readonly<LinePathOptions>): Path2D;

package/dist/lib/geometry/line.js

@@ -0,0 +1,15 @@
+import { validateCoordinates } from "./validation.js";
+function createLinePath(options) {
+  const coords = validateCoordinates(options.coords);
+  const path = new Path2D();
+  coords.forEach(([x, y], index) => {
+    if (index === 0) path.moveTo(x, y);
+    else path.lineTo(x, y);
+  });
+  if (options.closePath) path.closePath();
+  return path;
+}
+export {
+  createLinePath
+};
+//# sourceMappingURL=line.js.map

package/dist/lib/geometry/line.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/line.ts"],
+  "sourcesContent": ["import { validateCoordinates } from './validation.js';\n\n/**\n * Geometry and construction options for a line path.\n *\n * @see {@link createLinePath}\n */\nexport interface LinePathOptions {\n  /** Ordered coordinate pairs describing the path vertices. See {@link LinePathOptions}. */\n  coords: readonly (readonly [number, number])[];\n  /** Whether to connect the final vertex back to the first. See {@link LinePathOptions}. */\n  closePath?: boolean;\n}\n\n/**\n * Creates a Canvas Path2D for line geometry from validated options.\n *\n * @param options - Ordered vertices and whether to close the path. See {@link LinePathOptions}.\n * @returns A native Canvas path containing the line.\n *\n * @see {@link LinePathOptions}\n */\nexport function createLinePath(options: Readonly<LinePathOptions>): Path2D {\n  const coords = validateCoordinates(options.coords);\n  const path = new Path2D();\n  coords.forEach(([x, y], index) => {\n    if (index === 0) path.moveTo(x, y);\n    else path.lineTo(x, y);\n  });\n  if (options.closePath) path.closePath();\n  return path;\n}\n"],
+  "mappings": "AAAA,SAAS,2BAA2B;AAsB7B,SAAS,eAAe,SAA4C;AACzE,QAAM,SAAS,oBAAoB,QAAQ,MAAM;AACjD,QAAM,OAAO,IAAI,OAAO;AACxB,SAAO,QAAQ,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU;AAChC,QAAI,UAAU,EAAG,MAAK,OAAO,GAAG,CAAC;AAAA,QAC5B,MAAK,OAAO,GAAG,CAAC;AAAA,EACvB,CAAC;AACD,MAAI,QAAQ,UAAW,MAAK,UAAU;AACtC,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/geometry/path-arc.d.ts

@@ -0,0 +1,25 @@
+/** @internal Analytic arc representation shared by conversion and geometry math. */
+export interface ArcSegment {
+    type: 'arc';
+    cx: number;
+    cy: number;
+    ux: number;
+    uy: number;
+    vx: number;
+    vy: number;
+    startAngle: number;
+    sweep: number;
+}
+export declare const TAU: number;
+export declare function arcPoint(arc: ArcSegment, angle: number): [number, number];
+export declare function arcSweep(start: number, end: number, ccw: boolean): number;
+/** Singular-value decomposition of a 2x2 ellipse basis. */
+export declare function ellipseParameters(arc: ArcSegment): {
+    radiusX: number;
+    radiusY: number;
+    rotation: number;
+    start: number;
+    sweep: number;
+} | null;
+/** Preserve all turns in the traversal of an ellipse collapsed onto a line. */
+export declare function singularArcPoints(arc: ArcSegment): [number, number][];

package/dist/lib/geometry/path-arc.js

@@ -0,0 +1,57 @@
+const TAU = Math.PI * 2;
+function arcPoint(arc, angle) {
+  const cos = Math.cos(angle), sin = Math.sin(angle);
+  return [arc.cx + arc.ux * cos + arc.vx * sin, arc.cy + arc.uy * cos + arc.vy * sin];
+}
+function arcSweep(start, end, ccw) {
+  const delta = end - start;
+  if (!ccw && delta >= TAU) return TAU;
+  if (ccw && -delta >= TAU) return -TAU;
+  let sweep = (end % TAU - start % TAU) % TAU;
+  if (!ccw && sweep < 0) sweep += TAU;
+  if (ccw && sweep > 0) sweep -= TAU;
+  return sweep;
+}
+function ellipseParameters(arc) {
+  const scale = Math.max(Math.abs(arc.ux), Math.abs(arc.uy), Math.abs(arc.vx), Math.abs(arc.vy));
+  if (scale === 0) return null;
+  const ux = arc.ux / scale, uy = arc.uy / scale, vx = arc.vx / scale, vy = arc.vy / scale;
+  const determinant = ux * vy - uy * vx;
+  if (determinant === 0) return null;
+  const xx = ux * ux + vx * vx, yy = uy * uy + vy * vy, xy = ux * uy + vx * vy;
+  const rotation = Math.atan2(2 * xy, xx - yy) / 2;
+  const major = Math.sqrt((xx + yy + Math.hypot(xx - yy, 2 * xy)) / 2);
+  const minor = Math.abs(determinant) / major;
+  const cos = Math.cos(rotation), sin = Math.sin(rotation);
+  const phase = Math.atan2((-sin * ux + cos * uy) / minor, (cos * ux + sin * uy) / major);
+  const direction = determinant < 0 ? -1 : 1;
+  return {
+    radiusX: major * scale,
+    radiusY: minor * scale,
+    rotation,
+    start: phase + direction * arc.startAngle,
+    sweep: direction * arc.sweep
+  };
+}
+function singularArcPoints(arc) {
+  const useX = Math.hypot(arc.ux, arc.vx) >= Math.hypot(arc.uy, arc.vy);
+  const turning = Math.atan2(useX ? arc.vx : arc.vy, useX ? arc.ux : arc.uy);
+  const end = arc.startAngle + arc.sweep;
+  const low = Math.min(arc.startAngle, end), high = Math.max(arc.startAngle, end);
+  const angles = [];
+  for (let k = Math.ceil((low - turning) / Math.PI); k <= Math.floor((high - turning) / Math.PI); k++) {
+    const angle = turning + k * Math.PI;
+    if (angle > low && angle < high) angles.push(angle);
+  }
+  if (arc.sweep < 0) angles.reverse();
+  angles.push(end);
+  return angles.map((angle) => arcPoint(arc, angle));
+}
+export {
+  TAU,
+  arcPoint,
+  arcSweep,
+  ellipseParameters,
+  singularArcPoints
+};
+//# sourceMappingURL=path-arc.js.map

package/dist/lib/geometry/path-arc.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-arc.ts"],
+  "sourcesContent": ["/** @internal Analytic arc representation shared by conversion and geometry math. */\nexport interface ArcSegment {\n  type: 'arc';\n  cx: number; cy: number;\n  ux: number; uy: number;\n  vx: number; vy: number;\n  startAngle: number; sweep: number;\n}\nexport const TAU = Math.PI * 2;\nexport function arcPoint(arc: ArcSegment, angle: number): [number, number] {\n  const cos = Math.cos(angle), sin = Math.sin(angle);\n  return [arc.cx + arc.ux * cos + arc.vx * sin, arc.cy + arc.uy * cos + arc.vy * sin];\n}\nexport function arcSweep(start: number, end: number, ccw: boolean): number {\n  const delta = end - start;\n  if (!ccw && delta >= TAU) return TAU;\n  if (ccw && -delta >= TAU) return -TAU;\n  // Reducing separately also avoids overflow in end - start.\n  let sweep = ((end % TAU) - (start % TAU)) % TAU;\n  if (!ccw && sweep < 0) sweep += TAU;\n  if (ccw && sweep > 0) sweep -= TAU;\n  return sweep;\n}\n\n/** Singular-value decomposition of a 2x2 ellipse basis. */\nexport function ellipseParameters(arc: ArcSegment) {\n  const scale = Math.max(Math.abs(arc.ux), Math.abs(arc.uy), Math.abs(arc.vx), Math.abs(arc.vy));\n  if (scale === 0) return null;\n  const ux = arc.ux / scale, uy = arc.uy / scale, vx = arc.vx / scale, vy = arc.vy / scale;\n  const determinant = ux * vy - uy * vx;\n  if (determinant === 0) return null;\n  const xx = ux * ux + vx * vx, yy = uy * uy + vy * vy, xy = ux * uy + vx * vy;\n  const rotation = Math.atan2(2 * xy, xx - yy) / 2;\n  const major = Math.sqrt((xx + yy + Math.hypot(xx - yy, 2 * xy)) / 2);\n  const minor = Math.abs(determinant) / major;\n  const cos = Math.cos(rotation), sin = Math.sin(rotation);\n  const phase = Math.atan2((-sin * ux + cos * uy) / minor, (cos * ux + sin * uy) / major);\n  const direction = determinant < 0 ? -1 : 1;\n  return {\n    radiusX: major * scale, radiusY: minor * scale, rotation,\n    start: phase + direction * arc.startAngle, sweep: direction * arc.sweep,\n  };\n}\n\n/** Preserve all turns in the traversal of an ellipse collapsed onto a line. */\nexport function singularArcPoints(arc: ArcSegment): [number, number][] {\n  const useX = Math.hypot(arc.ux, arc.vx) >= Math.hypot(arc.uy, arc.vy);\n  const turning = Math.atan2(useX ? arc.vx : arc.vy, useX ? arc.ux : arc.uy);\n  const end = arc.startAngle + arc.sweep;\n  const low = Math.min(arc.startAngle, end), high = Math.max(arc.startAngle, end);\n  const angles: number[] = [];\n  for (let k = Math.ceil((low - turning) / Math.PI); k <= Math.floor((high - turning) / Math.PI); k++) {\n    const angle = turning + k * Math.PI;\n    if (angle > low && angle < high) angles.push(angle);\n  }\n  if (arc.sweep < 0) angles.reverse();\n  angles.push(end);\n  return angles.map(angle => arcPoint(arc, angle));\n}\n"],
+  "mappings": "AAQO,MAAM,MAAM,KAAK,KAAK;AACtB,SAAS,SAAS,KAAiB,OAAiC;AACzE,QAAM,MAAM,KAAK,IAAI,KAAK,GAAG,MAAM,KAAK,IAAI,KAAK;AACjD,SAAO,CAAC,IAAI,KAAK,IAAI,KAAK,MAAM,IAAI,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,IAAI,KAAK,GAAG;AACpF;AACO,SAAS,SAAS,OAAe,KAAa,KAAsB;AACzE,QAAM,QAAQ,MAAM;AACpB,MAAI,CAAC,OAAO,SAAS,IAAK,QAAO;AACjC,MAAI,OAAO,CAAC,SAAS,IAAK,QAAO,CAAC;AAElC,MAAI,SAAU,MAAM,MAAQ,QAAQ,OAAQ;AAC5C,MAAI,CAAC,OAAO,QAAQ,EAAG,UAAS;AAChC,MAAI,OAAO,QAAQ,EAAG,UAAS;AAC/B,SAAO;AACT;AAGO,SAAS,kBAAkB,KAAiB;AACjD,QAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC;AAC7F,MAAI,UAAU,EAAG,QAAO;AACxB,QAAM,KAAK,IAAI,KAAK,OAAO,KAAK,IAAI,KAAK,OAAO,KAAK,IAAI,KAAK,OAAO,KAAK,IAAI,KAAK;AACnF,QAAM,cAAc,KAAK,KAAK,KAAK;AACnC,MAAI,gBAAgB,EAAG,QAAO;AAC9B,QAAM,KAAK,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK;AAC1E,QAAM,WAAW,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,IAAI;AAC/C,QAAM,QAAQ,KAAK,MAAM,KAAK,KAAK,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,KAAK,CAAC;AACnE,QAAM,QAAQ,KAAK,IAAI,WAAW,IAAI;AACtC,QAAM,MAAM,KAAK,IAAI,QAAQ,GAAG,MAAM,KAAK,IAAI,QAAQ;AACvD,QAAM,QAAQ,KAAK,OAAO,CAAC,MAAM,KAAK,MAAM,MAAM,QAAQ,MAAM,KAAK,MAAM,MAAM,KAAK;AACtF,QAAM,YAAY,cAAc,IAAI,KAAK;AACzC,SAAO;AAAA,IACL,SAAS,QAAQ;AAAA,IAAO,SAAS,QAAQ;AAAA,IAAO;AAAA,IAChD,OAAO,QAAQ,YAAY,IAAI;AAAA,IAAY,OAAO,YAAY,IAAI;AAAA,EACpE;AACF;AAGO,SAAS,kBAAkB,KAAqC;AACrE,QAAM,OAAO,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,KAAK,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE;AACpE,QAAM,UAAU,KAAK,MAAM,OAAO,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,IAAI,EAAE;AACzE,QAAM,MAAM,IAAI,aAAa,IAAI;AACjC,QAAM,MAAM,KAAK,IAAI,IAAI,YAAY,GAAG,GAAG,OAAO,KAAK,IAAI,IAAI,YAAY,GAAG;AAC9E,QAAM,SAAmB,CAAC;AAC1B,WAAS,IAAI,KAAK,MAAM,MAAM,WAAW,KAAK,EAAE,GAAG,KAAK,KAAK,OAAO,OAAO,WAAW,KAAK,EAAE,GAAG,KAAK;AACnG,UAAM,QAAQ,UAAU,IAAI,KAAK;AACjC,QAAI,QAAQ,OAAO,QAAQ,KAAM,QAAO,KAAK,KAAK;AAAA,EACpD;AACA,MAAI,IAAI,QAAQ,EAAG,QAAO,QAAQ;AAClC,SAAO,KAAK,GAAG;AACf,SAAO,OAAO,IAAI,WAAS,SAAS,KAAK,KAAK,CAAC;AACjD;",
+  "names": []
+}

package/dist/lib/geometry/path-bend-guide.d.ts

@@ -0,0 +1,31 @@
+import { type BendPoint, type BendSpan } from './path-bend-spans.js';
+import { PathGeometry } from './path-geometry.js';
+interface Field {
+    readonly point: BendPoint;
+    readonly normal: BendPoint;
+}
+interface Knot extends Field {
+    readonly distance: number;
+}
+export interface PreparedBendGuide {
+    readonly spans: readonly BendSpan[];
+    readonly closed: boolean;
+    readonly scale: number;
+}
+/** Validate all guide contours and joins, even if the source uses only part. */
+export declare function prepareBendGuide(path: PathGeometry): PreparedBendGuide;
+/**
+ * A continuous piecewise-linear position/normal field with a certified error
+ * against the true arc-length field. Interpolated normals are deliberately NOT
+ * renormalized: this keeps the internal mapping bilinear within each leaf.
+ */
+export declare function measureBendGuide(prepared: PreparedBendGuide, tolerance: number, maxDisplacement: number, distanceFactor: (length: number) => number): {
+    length: number;
+    uncertainty: number;
+    error: number;
+    field: (distance: number, wrap: boolean) => Field;
+    knots: Knot[];
+    /** Conservative full-field residual, not a sampled flatness heuristic. */
+    chordError(low: number, high: number, s0: number, s1: number, d: number, ds: number, dds: number, dy: number, ddy: number, wrap: boolean): number;
+};
+export {};