@sprawlify/primitives 0.0.1

package/dist/stringify-state.d.cts

@@ -0,0 +1,8 @@
+//#region src/shared/stringify-state/index.d.ts
+interface Dict {
+  [key: string]: any;
+}
+declare function stringifyState(state: Dict, omit?: string[]): string;
+declare function highlightState(state: Dict, omit?: string[]): any;
+//#endregion
+export { highlightState, stringifyState };

package/dist/stringify-state.d.mts

@@ -0,0 +1,8 @@
+//#region src/shared/stringify-state/index.d.ts
+interface Dict {
+  [key: string]: any;
+}
+declare function stringifyState(state: Dict, omit?: string[]): string;
+declare function highlightState(state: Dict, omit?: string[]): any;
+//#endregion
+export { highlightState, stringifyState };

package/dist/stringify-state.mjs

@@ -0,0 +1,46 @@
+import formatHighlight from "json-format-highlight";
+
+//#region src/shared/stringify-state/index.ts
+const pick = (obj, keys) => Object.fromEntries(keys.filter((key) => key in obj).map((key) => [key, obj[key]]));
+const hasProp = (v, prop) => Object.prototype.hasOwnProperty.call(v, prop);
+const isTimeObject = (v) => hasProp(v, "hour") && hasProp(v, "minute") && hasProp(v, "second");
+const isMachine = (v) => [
+	"state",
+	"context",
+	"scope"
+].every((prop) => hasProp(v, prop));
+function stringifyState(state, omit) {
+	return JSON.stringify(state, (key, value) => {
+		try {
+			if (hasProp(value, "target") && hasProp(value, "timeStamp")) return pick(value, [
+				"type",
+				"target",
+				"currentTarget",
+				"relatedTarget"
+			]);
+			if (omit?.includes(key)) return;
+			if (hasProp(value, "calendar") || isTimeObject(value)) return value.toString();
+			if (typeof value?.json === "function") return value.json();
+			if (typeof value?.toJSON === "function") return value.toJSON();
+			if (Number.isNaN(value)) return "NaN";
+			if (value instanceof File) return value.name;
+			if (value instanceof Set) return Array.from(value);
+			if (isMachine(value)) return `Machine: ${value.scope.id}`;
+			switch (value?.toString()) {
+				case "[object ShadowRoot]": return "#shadow-root";
+				case "[object HTMLDocument]": return "#document";
+				case "[object Window]": return "#window";
+				case "[object AbortController]": return "#abort-controller";
+				default: return value !== null && typeof value === "object" && value.nodeType === 1 ? value.tagName : value;
+			}
+		} catch {
+			return value;
+		}
+	}, 4);
+}
+function highlightState(state, omit) {
+	return formatHighlight(stringifyState(state, omit));
+}
+
+//#endregion
+export { highlightState, stringifyState };

package/dist/tree-collection-BwU5WhGQ.d.mts

@@ -0,0 +1,78 @@
+import { c as FlatTreeNode, d as TreeCollectionMethods, f as TreeCollectionOptions, h as TreeSkipOptions, o as DescendantOptions, p as TreeNode, s as FilePathTreeNode, u as IndexPath } from "./types-Bl_6JtPQ.mjs";
+
+//#region src/shared/collection/tree-visit.d.ts
+
+interface BaseOptions<T> {
+  getChildren: (node: T, indexPath: IndexPath) => T[];
+  reuseIndexPath?: boolean | undefined;
+}
+type TreeVisitEnterReturnValue = void | "skip" | "stop";
+type TreeVisitLeaveReturnValue = void | "stop";
+interface TreeVisitOptions<T> extends BaseOptions<T> {
+  onEnter?(node: T, indexPath: IndexPath): TreeVisitEnterReturnValue;
+  onLeave?(node: T, indexPath: IndexPath): TreeVisitLeaveReturnValue;
+}
+//#endregion
+//#region src/shared/collection/tree-collection.d.ts
+declare class TreeCollection<T = TreeNode> {
+  private options;
+  rootNode: T;
+  constructor(options: TreeCollectionOptions<T>);
+  isEqual: (other: TreeCollection<T>) => boolean;
+  getNodeChildren: (node: T) => T[];
+  private resolveIndexPath;
+  private resolveNode;
+  getNodeChildrenCount: (node: T) => number | undefined;
+  getNodeValue: (node: T) => string;
+  getNodeDisabled: (node: T) => boolean;
+  stringify: (value: string) => string | null;
+  stringifyNode: (node: T) => string;
+  getFirstNode: (rootNode?: T) => T | undefined;
+  getLastNode: (rootNode?: T, opts?: TreeSkipOptions<T>) => T | undefined;
+  at: (indexPath: IndexPath) => T | undefined;
+  findNode: (value: string, rootNode?: T) => T | undefined;
+  findNodes: (values: string[], rootNode?: T) => T[];
+  sort: (values: string[]) => string[];
+  getIndexPath: (value: string) => IndexPath | undefined;
+  getValue: (indexPath: IndexPath) => string | undefined;
+  getValuePath: (indexPath: IndexPath | undefined) => string[];
+  getDepth: (value: string) => number;
+  isSameNode: (node: T, other: T) => boolean;
+  isRootNode: (node: T) => boolean;
+  contains: (parentIndexPath: IndexPath, valueIndexPath: IndexPath) => boolean;
+  getNextNode: (value: string, opts?: TreeSkipOptions<T>) => T | undefined;
+  getPreviousNode: (value: string, opts?: TreeSkipOptions<T>) => T | undefined;
+  getParentNodes: (valueOrIndexPath: string | IndexPath) => T[];
+  getDescendantNodes: (valueOrIndexPath: string | IndexPath, options?: DescendantOptions) => T[];
+  getDescendantValues: (valueOrIndexPath: string | IndexPath, options?: DescendantOptions) => string[];
+  private getParentIndexPath;
+  getParentNode: (valueOrIndexPath: string | IndexPath) => T | undefined;
+  visit: (opts: Omit<TreeVisitOptions<T>, "getChildren"> & TreeSkipOptions<T>) => void;
+  getPreviousSibling: (indexPath: IndexPath) => T | undefined;
+  getNextSibling: (indexPath: IndexPath) => T | undefined;
+  getSiblingNodes: (indexPath: IndexPath) => T[];
+  getValues: (rootNode?: T) => string[];
+  private isValidDepth;
+  isBranchNode: (node: T) => boolean;
+  getBranchValues: (rootNode?: T, opts?: TreeSkipOptions<T> & {
+    depth?: number | ((nodeDepth: number) => boolean) | undefined;
+  }) => string[];
+  flatten: (rootNode?: T) => Array<FlatTreeNode<T>>;
+  private _create;
+  private _insert;
+  copy: (rootNode: T) => TreeCollection<T>;
+  private _replace;
+  private _move;
+  private _remove;
+  replace: (indexPath: IndexPath, node: T) => TreeCollection<T>;
+  remove: (indexPaths: IndexPath[]) => TreeCollection<T>;
+  insertBefore: (indexPath: IndexPath, nodes: T[]) => TreeCollection<T> | undefined;
+  insertAfter: (indexPath: IndexPath, nodes: T[]) => TreeCollection<T> | undefined;
+  move: (fromIndexPaths: IndexPath[], toIndexPath: IndexPath) => TreeCollection<T>;
+  filter: (predicate: (node: T, indexPath: IndexPath) => boolean) => TreeCollection<T>;
+  toJSON: () => string[];
+}
+declare function flattenedToTree<T>(nodes: Array<FlatTreeNode<T>>, options?: TreeCollectionMethods<T>): TreeCollection<T>;
+declare function filePathToTree(paths: string[]): TreeCollection<FilePathTreeNode>;
+//#endregion
+export { filePathToTree as n, flattenedToTree as r, TreeCollection as t };

package/dist/tree-collection-DP_eznnI.d.cts

@@ -0,0 +1,78 @@
+import { c as FlatTreeNode, d as TreeCollectionMethods, f as TreeCollectionOptions, h as TreeSkipOptions, o as DescendantOptions, p as TreeNode, s as FilePathTreeNode, u as IndexPath } from "./types-BivBkYg9.cjs";
+
+//#region src/shared/collection/tree-visit.d.ts
+
+interface BaseOptions<T> {
+  getChildren: (node: T, indexPath: IndexPath) => T[];
+  reuseIndexPath?: boolean | undefined;
+}
+type TreeVisitEnterReturnValue = void | "skip" | "stop";
+type TreeVisitLeaveReturnValue = void | "stop";
+interface TreeVisitOptions<T> extends BaseOptions<T> {
+  onEnter?(node: T, indexPath: IndexPath): TreeVisitEnterReturnValue;
+  onLeave?(node: T, indexPath: IndexPath): TreeVisitLeaveReturnValue;
+}
+//#endregion
+//#region src/shared/collection/tree-collection.d.ts
+declare class TreeCollection<T = TreeNode> {
+  private options;
+  rootNode: T;
+  constructor(options: TreeCollectionOptions<T>);
+  isEqual: (other: TreeCollection<T>) => boolean;
+  getNodeChildren: (node: T) => T[];
+  private resolveIndexPath;
+  private resolveNode;
+  getNodeChildrenCount: (node: T) => number | undefined;
+  getNodeValue: (node: T) => string;
+  getNodeDisabled: (node: T) => boolean;
+  stringify: (value: string) => string | null;
+  stringifyNode: (node: T) => string;
+  getFirstNode: (rootNode?: T) => T | undefined;
+  getLastNode: (rootNode?: T, opts?: TreeSkipOptions<T>) => T | undefined;
+  at: (indexPath: IndexPath) => T | undefined;
+  findNode: (value: string, rootNode?: T) => T | undefined;
+  findNodes: (values: string[], rootNode?: T) => T[];
+  sort: (values: string[]) => string[];
+  getIndexPath: (value: string) => IndexPath | undefined;
+  getValue: (indexPath: IndexPath) => string | undefined;
+  getValuePath: (indexPath: IndexPath | undefined) => string[];
+  getDepth: (value: string) => number;
+  isSameNode: (node: T, other: T) => boolean;
+  isRootNode: (node: T) => boolean;
+  contains: (parentIndexPath: IndexPath, valueIndexPath: IndexPath) => boolean;
+  getNextNode: (value: string, opts?: TreeSkipOptions<T>) => T | undefined;
+  getPreviousNode: (value: string, opts?: TreeSkipOptions<T>) => T | undefined;
+  getParentNodes: (valueOrIndexPath: string | IndexPath) => T[];
+  getDescendantNodes: (valueOrIndexPath: string | IndexPath, options?: DescendantOptions) => T[];
+  getDescendantValues: (valueOrIndexPath: string | IndexPath, options?: DescendantOptions) => string[];
+  private getParentIndexPath;
+  getParentNode: (valueOrIndexPath: string | IndexPath) => T | undefined;
+  visit: (opts: Omit<TreeVisitOptions<T>, "getChildren"> & TreeSkipOptions<T>) => void;
+  getPreviousSibling: (indexPath: IndexPath) => T | undefined;
+  getNextSibling: (indexPath: IndexPath) => T | undefined;
+  getSiblingNodes: (indexPath: IndexPath) => T[];
+  getValues: (rootNode?: T) => string[];
+  private isValidDepth;
+  isBranchNode: (node: T) => boolean;
+  getBranchValues: (rootNode?: T, opts?: TreeSkipOptions<T> & {
+    depth?: number | ((nodeDepth: number) => boolean) | undefined;
+  }) => string[];
+  flatten: (rootNode?: T) => Array<FlatTreeNode<T>>;
+  private _create;
+  private _insert;
+  copy: (rootNode: T) => TreeCollection<T>;
+  private _replace;
+  private _move;
+  private _remove;
+  replace: (indexPath: IndexPath, node: T) => TreeCollection<T>;
+  remove: (indexPaths: IndexPath[]) => TreeCollection<T>;
+  insertBefore: (indexPath: IndexPath, nodes: T[]) => TreeCollection<T> | undefined;
+  insertAfter: (indexPath: IndexPath, nodes: T[]) => TreeCollection<T> | undefined;
+  move: (fromIndexPaths: IndexPath[], toIndexPath: IndexPath) => TreeCollection<T>;
+  filter: (predicate: (node: T, indexPath: IndexPath) => boolean) => TreeCollection<T>;
+  toJSON: () => string[];
+}
+declare function flattenedToTree<T>(nodes: Array<FlatTreeNode<T>>, options?: TreeCollectionMethods<T>): TreeCollection<T>;
+declare function filePathToTree(paths: string[]): TreeCollection<FilePathTreeNode>;
+//#endregion
+export { filePathToTree as n, flattenedToTree as r, TreeCollection as t };

package/dist/typeahead-BdNwVP09.d.cts

@@ -0,0 +1,45 @@
+//#region src/shared/dom-query/query.d.ts
+type Root = Document | Element | null | undefined;
+declare function queryAll<T extends Element = HTMLElement>(root: Root, selector: string): T[];
+declare function query<T extends Element = HTMLElement>(root: Root, selector: string): T | null;
+type ItemToId<T> = (v: T) => string;
+interface Item {
+  id: string;
+}
+declare const defaultItemToId: <T extends Item>(v: T) => string;
+declare function itemById<T extends Item>(v: T[], id: string, itemToId?: ItemToId<T>): T | undefined;
+declare function indexOfId<T extends Item>(v: T[], id: string, itemToId?: ItemToId<T>): number;
+declare function nextById<T extends Item>(v: T[], id: string, loop?: boolean): T;
+declare function prevById<T extends Item>(v: T[], id: string, loop?: boolean): T | null;
+//#endregion
+//#region src/shared/dom-query/searchable.d.ts
+interface SearchableItem {
+  id: string;
+  textContent: string | null;
+  dataset?: any | undefined;
+}
+declare function getByText<T extends SearchableItem>(v: T[], text: string, currentId?: string | null, itemToId?: ItemToId<T>): T | undefined;
+//#endregion
+//#region src/shared/dom-query/typeahead.d.ts
+interface TypeaheadState {
+  keysSoFar: string;
+  timer: number;
+}
+interface TypeaheadOptions<T> {
+  state: TypeaheadState;
+  activeId: string | null;
+  key: string;
+  timeout?: number | undefined;
+  itemToId?: ItemToId<T> | undefined;
+}
+declare function getByTypeaheadImpl<T extends SearchableItem>(baseItems: T[], options: TypeaheadOptions<T>): T | undefined;
+declare const getByTypeahead: typeof getByTypeaheadImpl & {
+  defaultOptions: {
+    keysSoFar: string;
+    timer: number;
+  };
+  isValidEvent: typeof isValidTypeaheadEvent;
+};
+declare function isValidTypeaheadEvent(event: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey">): boolean;
+//#endregion
+export { getByText as a, indexOfId as c, prevById as d, query as f, SearchableItem as i, itemById as l, TypeaheadState as n, ItemToId as o, queryAll as p, getByTypeahead as r, defaultItemToId as s, TypeaheadOptions as t, nextById as u };

package/dist/typeahead-XN6lZ7G9.d.mts

@@ -0,0 +1,45 @@
+//#region src/shared/dom-query/query.d.ts
+type Root = Document | Element | null | undefined;
+declare function queryAll<T extends Element = HTMLElement>(root: Root, selector: string): T[];
+declare function query<T extends Element = HTMLElement>(root: Root, selector: string): T | null;
+type ItemToId<T> = (v: T) => string;
+interface Item {
+  id: string;
+}
+declare const defaultItemToId: <T extends Item>(v: T) => string;
+declare function itemById<T extends Item>(v: T[], id: string, itemToId?: ItemToId<T>): T | undefined;
+declare function indexOfId<T extends Item>(v: T[], id: string, itemToId?: ItemToId<T>): number;
+declare function nextById<T extends Item>(v: T[], id: string, loop?: boolean): T;
+declare function prevById<T extends Item>(v: T[], id: string, loop?: boolean): T | null;
+//#endregion
+//#region src/shared/dom-query/searchable.d.ts
+interface SearchableItem {
+  id: string;
+  textContent: string | null;
+  dataset?: any | undefined;
+}
+declare function getByText<T extends SearchableItem>(v: T[], text: string, currentId?: string | null, itemToId?: ItemToId<T>): T | undefined;
+//#endregion
+//#region src/shared/dom-query/typeahead.d.ts
+interface TypeaheadState {
+  keysSoFar: string;
+  timer: number;
+}
+interface TypeaheadOptions<T> {
+  state: TypeaheadState;
+  activeId: string | null;
+  key: string;
+  timeout?: number | undefined;
+  itemToId?: ItemToId<T> | undefined;
+}
+declare function getByTypeaheadImpl<T extends SearchableItem>(baseItems: T[], options: TypeaheadOptions<T>): T | undefined;
+declare const getByTypeahead: typeof getByTypeaheadImpl & {
+  defaultOptions: {
+    keysSoFar: string;
+    timer: number;
+  };
+  isValidEvent: typeof isValidTypeaheadEvent;
+};
+declare function isValidTypeaheadEvent(event: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey">): boolean;
+//#endregion
+export { getByText as a, indexOfId as c, prevById as d, query as f, SearchableItem as i, itemById as l, TypeaheadState as n, ItemToId as o, queryAll as p, getByTypeahead as r, defaultItemToId as s, TypeaheadOptions as t, nextById as u };

package/dist/types-BivBkYg9.d.cts

@@ -0,0 +1,57 @@
+//#region src/shared/collection/types.d.ts
+interface CollectionSearchState {
+  keysSoFar: string;
+  timer: number;
+}
+interface CollectionSearchOptions {
+  state: CollectionSearchState;
+  currentValue: string | null;
+  timeout?: number | undefined;
+}
+type CollectionItem = any;
+interface CollectionMethods<T extends CollectionItem = CollectionItem> {
+  itemToValue: (item: T) => string;
+  itemToString: (item: T) => string;
+  isItemDisabled: (item: T) => boolean;
+}
+interface CollectionOptions<T extends CollectionItem = CollectionItem> extends Partial<CollectionMethods<T>> {
+  items: Iterable<T> | Readonly<Iterable<T>>;
+  groupBy?: ((item: T, index: number) => string) | undefined;
+  groupSort?: ((a: string, b: string) => number) | string[] | "asc" | "desc" | undefined;
+}
+type IndexPath = number[];
+type ValuePath = string[];
+interface TreeCollectionMethods<T> {
+  isNodeDisabled: (node: T) => boolean;
+  nodeToValue: (node: T) => string;
+  nodeToString: (node: T) => string;
+  nodeToChildren: (node: T) => any[];
+  nodeToChildrenCount: (node: T) => number | undefined;
+}
+interface TreeCollectionOptions<T> extends Partial<TreeCollectionMethods<T>> {
+  rootNode: T;
+}
+type TreeNode = any;
+type FilePathTreeNode<T = TreeNode> = T & {
+  children?: FilePathTreeNode<T>[] | undefined;
+};
+interface FlatTreeNodeMeta {
+  _children: number[] | undefined;
+  _parent: number | undefined;
+  _index: number;
+}
+type FlatTreeNode<T = TreeNode> = T & FlatTreeNodeMeta;
+interface TreeSkipFnArgs<T> {
+  value: string;
+  node: T;
+  indexPath: number[];
+}
+type TreeSkipFn<T> = (args: TreeSkipFnArgs<T>) => boolean | void;
+interface TreeSkipOptions<T> {
+  skip?: TreeSkipFn<T> | undefined;
+}
+interface DescendantOptions {
+  withBranch?: boolean;
+}
+//#endregion
+export { CollectionSearchState as a, FlatTreeNode as c, TreeCollectionMethods as d, TreeCollectionOptions as f, ValuePath as g, TreeSkipOptions as h, CollectionSearchOptions as i, FlatTreeNodeMeta as l, TreeSkipFn as m, CollectionMethods as n, DescendantOptions as o, TreeNode as p, CollectionOptions as r, FilePathTreeNode as s, CollectionItem as t, IndexPath as u };

package/dist/types-Bl_6JtPQ.d.mts

@@ -0,0 +1,57 @@
+//#region src/shared/collection/types.d.ts
+interface CollectionSearchState {
+  keysSoFar: string;
+  timer: number;
+}
+interface CollectionSearchOptions {
+  state: CollectionSearchState;
+  currentValue: string | null;
+  timeout?: number | undefined;
+}
+type CollectionItem = any;
+interface CollectionMethods<T extends CollectionItem = CollectionItem> {
+  itemToValue: (item: T) => string;
+  itemToString: (item: T) => string;
+  isItemDisabled: (item: T) => boolean;
+}
+interface CollectionOptions<T extends CollectionItem = CollectionItem> extends Partial<CollectionMethods<T>> {
+  items: Iterable<T> | Readonly<Iterable<T>>;
+  groupBy?: ((item: T, index: number) => string) | undefined;
+  groupSort?: ((a: string, b: string) => number) | string[] | "asc" | "desc" | undefined;
+}
+type IndexPath = number[];
+type ValuePath = string[];
+interface TreeCollectionMethods<T> {
+  isNodeDisabled: (node: T) => boolean;
+  nodeToValue: (node: T) => string;
+  nodeToString: (node: T) => string;
+  nodeToChildren: (node: T) => any[];
+  nodeToChildrenCount: (node: T) => number | undefined;
+}
+interface TreeCollectionOptions<T> extends Partial<TreeCollectionMethods<T>> {
+  rootNode: T;
+}
+type TreeNode = any;
+type FilePathTreeNode<T = TreeNode> = T & {
+  children?: FilePathTreeNode<T>[] | undefined;
+};
+interface FlatTreeNodeMeta {
+  _children: number[] | undefined;
+  _parent: number | undefined;
+  _index: number;
+}
+type FlatTreeNode<T = TreeNode> = T & FlatTreeNodeMeta;
+interface TreeSkipFnArgs<T> {
+  value: string;
+  node: T;
+  indexPath: number[];
+}
+type TreeSkipFn<T> = (args: TreeSkipFnArgs<T>) => boolean | void;
+interface TreeSkipOptions<T> {
+  skip?: TreeSkipFn<T> | undefined;
+}
+interface DescendantOptions {
+  withBranch?: boolean;
+}
+//#endregion
+export { CollectionSearchState as a, FlatTreeNode as c, TreeCollectionMethods as d, TreeCollectionOptions as f, ValuePath as g, TreeSkipOptions as h, CollectionSearchOptions as i, FlatTreeNodeMeta as l, TreeSkipFn as m, CollectionMethods as n, DescendantOptions as o, TreeNode as p, CollectionOptions as r, FilePathTreeNode as s, CollectionItem as t, IndexPath as u };

package/dist/types-CPUMVt7c.d.mts

@@ -0,0 +1,54 @@
+//#region src/shared/rect-utils/types.d.ts
+interface Point {
+  x: number;
+  y: number;
+}
+interface Size {
+  width: number;
+  height: number;
+}
+interface Bounds {
+  minX: number;
+  midX: number;
+  maxX: number;
+  minY: number;
+  midY: number;
+  maxY: number;
+}
+interface CenterPoint {
+  center: Point;
+}
+interface RectInit extends Point, Size {}
+interface Rect extends Point, Size, Bounds, CenterPoint {}
+type RectSide = "top" | "right" | "bottom" | "left";
+type RectPoint = "top-left" | "top-center" | "top-right" | "right-center" | "left-center" | "bottom-left" | "bottom-right" | "bottom-center" | "center";
+type RectEdge = [Point, Point];
+type RectPoints = [Point, Point, Point, Point];
+type RectEdges = Record<RectSide, RectEdge> & {
+  value: RectEdge[];
+};
+type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+type RectCorners = Record<RectCorner, Point> & {
+  value: RectPoints;
+};
+type RectCenter = "topCenter" | "rightCenter" | "leftCenter" | "bottomCenter";
+type RectCenters = Record<RectCenter, Point> & {
+  value: RectPoints;
+};
+type RectInset = Partial<Record<RectSide, number>>;
+interface SymmetricRectInset {
+  dx?: number | undefined;
+  dy?: number | undefined;
+}
+interface ScalingOptions {
+  scalingOriginMode: "center" | "extent";
+  lockAspectRatio: boolean;
+}
+interface AlignOptions {
+  h: HAlign;
+  v: VAlign;
+}
+type HAlign = "left-inside" | "left-outside" | "center" | "right-inside" | "right-outside";
+type VAlign = "top-inside" | "top-outside" | "center" | "bottom-inside" | "bottom-outside";
+//#endregion
+export { RectSide as _, Point as a, SymmetricRectInset as b, RectCenters as c, RectEdge as d, RectEdges as f, RectPoints as g, RectPoint as h, HAlign as i, RectCorner as l, RectInset as m, Bounds as n, Rect as o, RectInit as p, CenterPoint as r, RectCenter as s, AlignOptions as t, RectCorners as u, ScalingOptions as v, VAlign as x, Size as y };

package/dist/types-CT_W6HWr.d.cts

@@ -0,0 +1,54 @@
+//#region src/shared/rect-utils/types.d.ts
+interface Point {
+  x: number;
+  y: number;
+}
+interface Size {
+  width: number;
+  height: number;
+}
+interface Bounds {
+  minX: number;
+  midX: number;
+  maxX: number;
+  minY: number;
+  midY: number;
+  maxY: number;
+}
+interface CenterPoint {
+  center: Point;
+}
+interface RectInit extends Point, Size {}
+interface Rect extends Point, Size, Bounds, CenterPoint {}
+type RectSide = "top" | "right" | "bottom" | "left";
+type RectPoint = "top-left" | "top-center" | "top-right" | "right-center" | "left-center" | "bottom-left" | "bottom-right" | "bottom-center" | "center";
+type RectEdge = [Point, Point];
+type RectPoints = [Point, Point, Point, Point];
+type RectEdges = Record<RectSide, RectEdge> & {
+  value: RectEdge[];
+};
+type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+type RectCorners = Record<RectCorner, Point> & {
+  value: RectPoints;
+};
+type RectCenter = "topCenter" | "rightCenter" | "leftCenter" | "bottomCenter";
+type RectCenters = Record<RectCenter, Point> & {
+  value: RectPoints;
+};
+type RectInset = Partial<Record<RectSide, number>>;
+interface SymmetricRectInset {
+  dx?: number | undefined;
+  dy?: number | undefined;
+}
+interface ScalingOptions {
+  scalingOriginMode: "center" | "extent";
+  lockAspectRatio: boolean;
+}
+interface AlignOptions {
+  h: HAlign;
+  v: VAlign;
+}
+type HAlign = "left-inside" | "left-outside" | "center" | "right-inside" | "right-outside";
+type VAlign = "top-inside" | "top-outside" | "center" | "bottom-inside" | "bottom-outside";
+//#endregion
+export { RectSide as _, Point as a, SymmetricRectInset as b, RectCenters as c, RectEdge as d, RectEdges as f, RectPoints as g, RectPoint as h, HAlign as i, RectCorner as l, RectInset as m, Bounds as n, Rect as o, RectInit as p, CenterPoint as r, RectCenter as s, AlignOptions as t, RectCorners as u, ScalingOptions as v, VAlign as x, Size as y };