@sprawlify/primitives 0.0.1

package/dist/types-DDTcG99l.d.mts

@@ -0,0 +1,201 @@
+//#region src/shared/core/types.d.ts
+type Dict = Record<string, any>;
+interface ComputedParams<T extends Dict> {
+  context: BindableContext<T>;
+  event: EventType<T["event"]>;
+  prop: PropFn<T>;
+  refs: BindableRefs<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+}
+interface ContextParams<T extends Dict> {
+  prop: PropFn<T>;
+  bindable: BindableFn;
+  scope: Scope;
+  getContext: () => BindableContext<T>;
+  getComputed: () => ComputedFn<T>;
+  getRefs: () => BindableRefs<T>;
+  getEvent: () => EventType<T["event"]>;
+  flush: (fn: VoidFunction) => void;
+}
+interface PropFn<T extends Dict> {
+  <K$1 extends keyof T["props"]>(key: K$1): T["props"][K$1];
+}
+interface ComputedFn<T extends Dict> {
+  <K$1 extends keyof T["computed"]>(key: K$1): T["computed"][K$1];
+}
+type AnyFunction = () => string | number | boolean | null | undefined;
+type TrackFn = (deps: AnyFunction[], fn: VoidFunction) => void;
+interface BindableParams<T> {
+  defaultValue?: T | undefined;
+  value?: T | undefined;
+  hash?: ((a: T) => string) | undefined;
+  isEqual?: ((a: T, b: T | undefined) => boolean) | undefined;
+  onChange?: ((value: T, prev: T | undefined) => void) | undefined;
+  debug?: string | undefined;
+  sync?: boolean | undefined;
+}
+type ValueOrFn<T> = T | ((prev: T) => T);
+interface Bindable<T> {
+  initial: T | undefined;
+  ref: any;
+  get: () => T;
+  set(value: ValueOrFn<T>): void;
+  invoke(nextValue: T, prevValue: T): void;
+  hash(value: T): string;
+}
+interface BindableRefs<T extends Dict> {
+  set<K$1 extends keyof T["refs"]>(key: K$1, value: T["refs"][K$1]): void;
+  get<K$1 extends keyof T["refs"]>(key: K$1): T["refs"][K$1];
+}
+interface BindableContext<T extends Dict> {
+  set<K$1 extends keyof T["context"]>(key: K$1, value: ValueOrFn<T["context"][K$1]>): void;
+  get<K$1 extends keyof T["context"]>(key: K$1): T["context"][K$1];
+  initial<K$1 extends keyof T["context"]>(key: K$1): T["context"][K$1];
+  hash<K$1 extends keyof T["context"]>(key: K$1): string;
+}
+interface BindableRef<T> {
+  get: () => T;
+  set: (next: T) => void;
+}
+interface BindableFn {
+  <K$1>(params: () => BindableParams<K$1>): Bindable<K$1>;
+  cleanup: (fn: VoidFunction) => void;
+  ref: <T>(defaultValue: T) => BindableRef<T>;
+}
+interface Scope {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode: () => ShadowRoot | Document | Node;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: (elem: HTMLElement | null) => boolean;
+  getDoc: () => typeof document;
+  getWin: () => typeof window;
+}
+type EventType<T = any> = T & {
+  previousEvent?: (T & {
+    [key: string]: any;
+  }) | undefined;
+  src?: string | undefined;
+  [key: string]: any;
+};
+type EventObject = EventType<{
+  type: string;
+}>;
+interface Params<T extends Dict> {
+  prop: PropFn<T>;
+  action: (action: T["action"][]) => void;
+  context: BindableContext<T>;
+  refs: BindableRefs<T>;
+  track: TrackFn;
+  flush: (fn: VoidFunction) => void;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+  send: (event: EventType<T["event"]>) => void;
+  computed: ComputedFn<T>;
+  scope: Scope;
+  state: Bindable<T["state"]> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  choose: ChooseFn<T>;
+  guard: (key: T["guard"] | GuardFn<T>) => boolean | undefined;
+}
+type GuardFn<T extends Dict> = (params: Params<T>) => boolean;
+interface Transition<T extends Dict> {
+  target?: T["state"] | undefined;
+  actions?: T["action"][] | undefined;
+  guard?: T["guard"] | GuardFn<T> | undefined;
+  reenter?: boolean | undefined;
+}
+type MaybeArray<T> = T | T[];
+type ChooseFn<T extends Dict> = (transitions: MaybeArray<Omit<Transition<T>, "target">>) => Transition<T> | undefined;
+interface PropsParams<T extends Dict> {
+  props: Partial<T["props"]>;
+  scope: Scope;
+}
+interface RefsParams<T extends Dict> {
+  prop: PropFn<T>;
+  context: BindableContext<T>;
+}
+type ActionsOrFn<T extends Dict> = T["action"][] | ((params: Params<T>) => T["action"][] | undefined);
+type EffectsOrFn<T extends Dict> = T["effect"][] | ((params: Params<T>) => T["effect"][] | undefined);
+interface Machine<T extends Dict> {
+  debug?: boolean | undefined;
+  props?: ((params: PropsParams<T>) => T["props"]) | undefined;
+  context?: ((params: ContextParams<T>) => { [K in keyof T["context"]]: Bindable<T["context"][K]> }) | undefined;
+  computed?: { [K in keyof T["computed"]]: (params: ComputedParams<T>) => T["computed"][K] } | undefined;
+  initialState: (params: {
+    prop: PropFn<T>;
+  }) => T["state"];
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  refs?: ((params: RefsParams<T>) => T["refs"]) | undefined;
+  watch?: ((params: Params<T>) => void) | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T> | Array<Transition<T>> } | undefined;
+  states: { [K in T["state"]]: {
+    tags?: T["tag"][] | undefined;
+    entry?: ActionsOrFn<T> | undefined;
+    exit?: ActionsOrFn<T> | undefined;
+    effects?: EffectsOrFn<T> | undefined;
+    on?: { [E in T["event"]["type"]]?: Transition<T> | Array<Transition<T>> } | undefined;
+  } };
+  implementations?: {
+    guards?: { [K in T["guard"]]: (params: Params<T>) => boolean } | undefined;
+    actions?: { [K in T["action"]]: (params: Params<T>) => void } | undefined;
+    effects?: { [K in T["effect"]]: (params: Params<T>) => void | VoidFunction } | undefined;
+  } | undefined;
+}
+interface MachineBaseProps {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode?: (() => ShadowRoot | Document | Node) | undefined;
+  [key: string]: any;
+}
+interface MachineSchema {
+  props?: MachineBaseProps | undefined;
+  context?: Record<string, any> | undefined;
+  refs?: Record<string, any> | undefined;
+  computed?: Record<string, any> | undefined;
+  state?: string | undefined;
+  tag?: string | undefined;
+  guard?: string | undefined;
+  action?: string | undefined;
+  effect?: string | undefined;
+  event?: ({
+    type: string;
+  } & Dict) | undefined;
+}
+type State<T extends MachineSchema> = Bindable<T["state"]> & {
+  hasTag: (tag: T["tag"]) => boolean;
+  matches: (...values: T["state"][]) => boolean;
+};
+type Service<T extends MachineSchema> = {
+  getStatus: () => MachineStatus;
+  state: State<T> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  context: BindableContext<T>;
+  send: (event: EventType<T["event"]>) => void;
+  prop: PropFn<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+  refs: BindableRefs<T>;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+};
+declare enum MachineStatus {
+  NotStarted = "Not Started",
+  Started = "Started",
+  Stopped = "Stopped",
+}
+declare const INIT_STATE = "__init__";
+//#endregion
+export { PropFn as _, BindableParams as a, Transition as b, ComputedFn as c, GuardFn as d, INIT_STATE as f, Params as g, MachineStatus as h, BindableFn as i, EffectsOrFn as l, MachineSchema as m, Bindable as n, BindableRefs as o, Machine as p, BindableContext as r, ChooseFn as s, ActionsOrFn as t, EventObject as u, Scope as v, ValueOrFn as x, Service as y };

package/dist/types-DejIu60O.d.cts

@@ -0,0 +1,201 @@
+//#region src/shared/core/types.d.ts
+type Dict = Record<string, any>;
+interface ComputedParams<T extends Dict> {
+  context: BindableContext<T>;
+  event: EventType<T["event"]>;
+  prop: PropFn<T>;
+  refs: BindableRefs<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+}
+interface ContextParams<T extends Dict> {
+  prop: PropFn<T>;
+  bindable: BindableFn;
+  scope: Scope;
+  getContext: () => BindableContext<T>;
+  getComputed: () => ComputedFn<T>;
+  getRefs: () => BindableRefs<T>;
+  getEvent: () => EventType<T["event"]>;
+  flush: (fn: VoidFunction) => void;
+}
+interface PropFn<T extends Dict> {
+  <K$1 extends keyof T["props"]>(key: K$1): T["props"][K$1];
+}
+interface ComputedFn<T extends Dict> {
+  <K$1 extends keyof T["computed"]>(key: K$1): T["computed"][K$1];
+}
+type AnyFunction = () => string | number | boolean | null | undefined;
+type TrackFn = (deps: AnyFunction[], fn: VoidFunction) => void;
+interface BindableParams<T> {
+  defaultValue?: T | undefined;
+  value?: T | undefined;
+  hash?: ((a: T) => string) | undefined;
+  isEqual?: ((a: T, b: T | undefined) => boolean) | undefined;
+  onChange?: ((value: T, prev: T | undefined) => void) | undefined;
+  debug?: string | undefined;
+  sync?: boolean | undefined;
+}
+type ValueOrFn<T> = T | ((prev: T) => T);
+interface Bindable<T> {
+  initial: T | undefined;
+  ref: any;
+  get: () => T;
+  set(value: ValueOrFn<T>): void;
+  invoke(nextValue: T, prevValue: T): void;
+  hash(value: T): string;
+}
+interface BindableRefs<T extends Dict> {
+  set<K$1 extends keyof T["refs"]>(key: K$1, value: T["refs"][K$1]): void;
+  get<K$1 extends keyof T["refs"]>(key: K$1): T["refs"][K$1];
+}
+interface BindableContext<T extends Dict> {
+  set<K$1 extends keyof T["context"]>(key: K$1, value: ValueOrFn<T["context"][K$1]>): void;
+  get<K$1 extends keyof T["context"]>(key: K$1): T["context"][K$1];
+  initial<K$1 extends keyof T["context"]>(key: K$1): T["context"][K$1];
+  hash<K$1 extends keyof T["context"]>(key: K$1): string;
+}
+interface BindableRef<T> {
+  get: () => T;
+  set: (next: T) => void;
+}
+interface BindableFn {
+  <K$1>(params: () => BindableParams<K$1>): Bindable<K$1>;
+  cleanup: (fn: VoidFunction) => void;
+  ref: <T>(defaultValue: T) => BindableRef<T>;
+}
+interface Scope {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode: () => ShadowRoot | Document | Node;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: (elem: HTMLElement | null) => boolean;
+  getDoc: () => typeof document;
+  getWin: () => typeof window;
+}
+type EventType<T = any> = T & {
+  previousEvent?: (T & {
+    [key: string]: any;
+  }) | undefined;
+  src?: string | undefined;
+  [key: string]: any;
+};
+type EventObject = EventType<{
+  type: string;
+}>;
+interface Params<T extends Dict> {
+  prop: PropFn<T>;
+  action: (action: T["action"][]) => void;
+  context: BindableContext<T>;
+  refs: BindableRefs<T>;
+  track: TrackFn;
+  flush: (fn: VoidFunction) => void;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+  send: (event: EventType<T["event"]>) => void;
+  computed: ComputedFn<T>;
+  scope: Scope;
+  state: Bindable<T["state"]> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  choose: ChooseFn<T>;
+  guard: (key: T["guard"] | GuardFn<T>) => boolean | undefined;
+}
+type GuardFn<T extends Dict> = (params: Params<T>) => boolean;
+interface Transition<T extends Dict> {
+  target?: T["state"] | undefined;
+  actions?: T["action"][] | undefined;
+  guard?: T["guard"] | GuardFn<T> | undefined;
+  reenter?: boolean | undefined;
+}
+type MaybeArray<T> = T | T[];
+type ChooseFn<T extends Dict> = (transitions: MaybeArray<Omit<Transition<T>, "target">>) => Transition<T> | undefined;
+interface PropsParams<T extends Dict> {
+  props: Partial<T["props"]>;
+  scope: Scope;
+}
+interface RefsParams<T extends Dict> {
+  prop: PropFn<T>;
+  context: BindableContext<T>;
+}
+type ActionsOrFn<T extends Dict> = T["action"][] | ((params: Params<T>) => T["action"][] | undefined);
+type EffectsOrFn<T extends Dict> = T["effect"][] | ((params: Params<T>) => T["effect"][] | undefined);
+interface Machine<T extends Dict> {
+  debug?: boolean | undefined;
+  props?: ((params: PropsParams<T>) => T["props"]) | undefined;
+  context?: ((params: ContextParams<T>) => { [K in keyof T["context"]]: Bindable<T["context"][K]> }) | undefined;
+  computed?: { [K in keyof T["computed"]]: (params: ComputedParams<T>) => T["computed"][K] } | undefined;
+  initialState: (params: {
+    prop: PropFn<T>;
+  }) => T["state"];
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  refs?: ((params: RefsParams<T>) => T["refs"]) | undefined;
+  watch?: ((params: Params<T>) => void) | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T> | Array<Transition<T>> } | undefined;
+  states: { [K in T["state"]]: {
+    tags?: T["tag"][] | undefined;
+    entry?: ActionsOrFn<T> | undefined;
+    exit?: ActionsOrFn<T> | undefined;
+    effects?: EffectsOrFn<T> | undefined;
+    on?: { [E in T["event"]["type"]]?: Transition<T> | Array<Transition<T>> } | undefined;
+  } };
+  implementations?: {
+    guards?: { [K in T["guard"]]: (params: Params<T>) => boolean } | undefined;
+    actions?: { [K in T["action"]]: (params: Params<T>) => void } | undefined;
+    effects?: { [K in T["effect"]]: (params: Params<T>) => void | VoidFunction } | undefined;
+  } | undefined;
+}
+interface MachineBaseProps {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode?: (() => ShadowRoot | Document | Node) | undefined;
+  [key: string]: any;
+}
+interface MachineSchema {
+  props?: MachineBaseProps | undefined;
+  context?: Record<string, any> | undefined;
+  refs?: Record<string, any> | undefined;
+  computed?: Record<string, any> | undefined;
+  state?: string | undefined;
+  tag?: string | undefined;
+  guard?: string | undefined;
+  action?: string | undefined;
+  effect?: string | undefined;
+  event?: ({
+    type: string;
+  } & Dict) | undefined;
+}
+type State<T extends MachineSchema> = Bindable<T["state"]> & {
+  hasTag: (tag: T["tag"]) => boolean;
+  matches: (...values: T["state"][]) => boolean;
+};
+type Service<T extends MachineSchema> = {
+  getStatus: () => MachineStatus;
+  state: State<T> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  context: BindableContext<T>;
+  send: (event: EventType<T["event"]>) => void;
+  prop: PropFn<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+  refs: BindableRefs<T>;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+};
+declare enum MachineStatus {
+  NotStarted = "Not Started",
+  Started = "Started",
+  Stopped = "Stopped",
+}
+declare const INIT_STATE = "__init__";
+//#endregion
+export { PropFn as _, BindableParams as a, Transition as b, ComputedFn as c, GuardFn as d, INIT_STATE as f, Params as g, MachineStatus as h, BindableFn as i, EffectsOrFn as l, MachineSchema as m, Bindable as n, BindableRefs as o, Machine as p, BindableContext as r, ChooseFn as s, ActionsOrFn as t, EventObject as u, Scope as v, ValueOrFn as x, Service as y };

package/dist/types-DiIdKZ3K.d.cts

@@ -0,0 +1,45 @@
+import { AutoUpdateOptions, Boundary, ComputePositionReturn, Placement as Placement$1, VirtualElement } from "@floating-ui/dom";
+
+//#region src/shared/popper/types.d.ts
+type MaybeRectElement = HTMLElement | VirtualElement | null;
+type MaybeElement = HTMLElement | null;
+type MaybeFn<T> = T | (() => T);
+type PlacementSide = "top" | "right" | "bottom" | "left";
+type PlacementAlign = "start" | "center" | "end";
+interface AnchorRect {
+  x?: number | undefined;
+  y?: number | undefined;
+  width?: number | undefined;
+  height?: number | undefined;
+}
+interface PositioningOptions {
+  hideWhenDetached?: boolean | undefined;
+  strategy?: "absolute" | "fixed" | undefined;
+  placement?: Placement$1 | undefined;
+  offset?: {
+    mainAxis?: number | undefined;
+    crossAxis?: number | undefined;
+  } | undefined;
+  gutter?: number | undefined;
+  shift?: number | undefined;
+  overflowPadding?: number | undefined;
+  arrowPadding?: number | undefined;
+  flip?: boolean | Placement$1[] | undefined;
+  slide?: boolean | undefined;
+  overlap?: boolean | undefined;
+  sameWidth?: boolean | undefined;
+  fitViewport?: boolean | undefined;
+  boundary?: (() => Boundary) | Boundary | "clipping-ancestors" | undefined;
+  listeners?: boolean | AutoUpdateOptions | undefined;
+  onComplete?: ((data: ComputePositionReturn) => void) | undefined;
+  onPositioned?: ((data: {
+    placed: boolean;
+  }) => void) | undefined;
+  getAnchorRect?: ((element: HTMLElement | VirtualElement | null) => AnchorRect | null) | undefined;
+  updatePosition?: ((data: {
+    updatePosition: () => Promise<void>;
+    floatingElement: HTMLElement | null;
+  }) => void | Promise<void>) | undefined;
+}
+//#endregion
+export { MaybeElement as a, Placement$1 as c, PositioningOptions as d, ComputePositionReturn as i, PlacementAlign as l, AutoUpdateOptions as n, MaybeFn as o, Boundary as r, MaybeRectElement as s, AnchorRect as t, PlacementSide as u };

package/dist/types-GxLIgJib.d.cts

@@ -0,0 +1,17 @@
+import { DateFormatter, DateValue } from "@internationalized/date";
+
+//#region src/shared/date-utils/types.d.ts
+type DateGranularity = "day" | "hour" | "minute" | "second" | "year" | "month";
+type DateAlignment = "start" | "end" | "center";
+type DateAvailableFn = (date: DateValue, locale: string) => boolean;
+type DateAdjustFn = (options: {
+  startDate: DateValue;
+  focusedDate: DateValue;
+}) => {
+  startDate: DateValue;
+  focusedDate: DateValue;
+  endDate: DateValue;
+};
+type DateRangePreset = "thisWeek" | "lastWeek" | "thisMonth" | "lastMonth" | "thisQuarter" | "lastQuarter" | "thisYear" | "lastYear" | "last3Days" | "last7Days" | "last14Days" | "last30Days" | "last90Days";
+//#endregion
+export { DateRangePreset as a, DateGranularity as i, DateAlignment as n, DateAvailableFn as r, DateAdjustFn as t };

package/dist/types.cjs

@@ -0,0 +1,15 @@
+const require_create_props = require('./create-props-YKy7JIKj.cjs');
+
+//#region src/shared/types/prop-types.ts
+function createNormalizer(fn) {
+	return new Proxy({}, { get(_target, key) {
+		if (key === "style") return (props) => {
+			return fn({ style: props }).style;
+		};
+		return fn;
+	} });
+}
+
+//#endregion
+exports.createNormalizer = createNormalizer;
+exports.createProps = require_create_props.createProps;

package/dist/types.d.cts

@@ -0,0 +1,2 @@
+import { C as JSX, S as createNormalizer, _ as Size, a as EventKeyMap, b as NormalizeProps, c as MaybeFn, d as Orientation, f as OrientationProperty, g as RequiredBy, h as Required, i as EventKey, l as NonNullable, m as Rect, n as Direction, o as LocaleProperties, p as Point, r as DirectionProperty, s as MaybeElement, t as CommonProperties, u as Nullable, v as Style, x as PropTypes, y as createProps } from "./index-Bqw3r34-.cjs";
+export { CommonProperties, Direction, DirectionProperty, EventKey, EventKeyMap, JSX, LocaleProperties, MaybeElement, MaybeFn, NonNullable, NormalizeProps, Nullable, Orientation, OrientationProperty, Point, PropTypes, Rect, Required, RequiredBy, Size, Style, createNormalizer, createProps };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { C as JSX, S as createNormalizer, _ as Size, a as EventKeyMap, b as NormalizeProps, c as MaybeFn, d as Orientation, f as OrientationProperty, g as RequiredBy, h as Required, i as EventKey, l as NonNullable, m as Rect, n as Direction, o as LocaleProperties, p as Point, r as DirectionProperty, s as MaybeElement, t as CommonProperties, u as Nullable, v as Style, x as PropTypes, y as createProps } from "./index-C0MKXQmE.mjs";
+export { CommonProperties, Direction, DirectionProperty, EventKey, EventKeyMap, JSX, LocaleProperties, MaybeElement, MaybeFn, NonNullable, NormalizeProps, Nullable, Orientation, OrientationProperty, Point, PropTypes, Rect, Required, RequiredBy, Size, Style, createNormalizer, createProps };

package/dist/types.mjs

@@ -0,0 +1,14 @@
+import { t as createProps } from "./create-props-BnF_vl-E.mjs";
+
+//#region src/shared/types/prop-types.ts
+function createNormalizer(fn) {
+	return new Proxy({}, { get(_target, key) {
+		if (key === "style") return (props) => {
+			return fn({ style: props }).style;
+		};
+		return fn;
+	} });
+}
+
+//#endregion
+export { createNormalizer, createProps };