@smuikit/core 0.1.0

package/dist/chunk-3SIG5GVW.mjs

@@ -0,0 +1,94 @@
+import { getAriaDisabled } from './chunk-IRJ3PEU4.mjs';
+import { createMachine } from './chunk-YFNMWGC7.mjs';
+
+// src/machines/button/button.machine.ts
+function createButtonMachine(initialContext) {
+  return createMachine({
+    id: "button",
+    initial: "idle",
+    context: {
+      disabled: false,
+      loading: false,
+      variant: "primary",
+      size: "md",
+      ...initialContext
+    },
+    states: {
+      idle: {
+        on: {
+          PRESS: "pressed",
+          FOCUS: "focused",
+          SET_LOADING: {
+            target: "idle",
+            actions: (_ctx, event) => ({ loading: event.loading })
+          },
+          SET_DISABLED: {
+            target: "idle",
+            actions: (_ctx, event) => ({ disabled: event.disabled })
+          }
+        }
+      },
+      pressed: {
+        on: {
+          RELEASE: "idle",
+          BLUR: "idle"
+        }
+      },
+      focused: {
+        on: {
+          PRESS: "pressed",
+          BLUR: "idle"
+        }
+      }
+    }
+  });
+}
+
+// src/machines/button/button.connect.ts
+function connectButton(options) {
+  const { state, context, send, onClick } = options;
+  const { disabled, loading, variant, size } = context;
+  const isDisabled = disabled || loading;
+  return {
+    state,
+    isDisabled,
+    isLoading: loading,
+    rootProps: {
+      role: "button",
+      type: "button",
+      disabled: isDisabled,
+      "data-state": state,
+      "data-variant": variant,
+      "data-size": size,
+      ...getAriaDisabled(isDisabled),
+      ...loading ? { "aria-busy": true } : {},
+      onClick: (event) => {
+        if (isDisabled) return;
+        onClick?.(event);
+      },
+      onPointerDown: () => {
+        if (isDisabled) return;
+        send({ type: "PRESS" });
+      },
+      onPointerUp: () => {
+        if (isDisabled) return;
+        send({ type: "RELEASE" });
+      },
+      onFocus: () => {
+        if (isDisabled) return;
+        send({ type: "FOCUS" });
+      },
+      onBlur: () => {
+        send({ type: "BLUR" });
+      }
+    },
+    loadingProps: {
+      "aria-hidden": true,
+      style: {
+        display: loading ? "inline-flex" : "none"
+      }
+    }
+  };
+}
+
+export { connectButton, createButtonMachine };

package/dist/chunk-CG7MB4D7.mjs

@@ -0,0 +1,139 @@
+import { getAriaRequired, getAriaInvalid, getAriaDisabled } from './chunk-IRJ3PEU4.mjs';
+import { createMachine } from './chunk-YFNMWGC7.mjs';
+
+// src/machines/input/input.machine.ts
+function createInputMachine(initialContext) {
+  const id = initialContext?.id || `input-${Date.now()}`;
+  return createMachine({
+    id: "input",
+    initial: "idle",
+    context: {
+      value: "",
+      disabled: false,
+      readOnly: false,
+      required: false,
+      error: null,
+      placeholder: "",
+      label: "",
+      id,
+      ...initialContext
+    },
+    states: {
+      idle: {
+        on: {
+          FOCUS: "focused",
+          CHANGE: {
+            target: "filled",
+            actions: (_ctx, event) => ({ value: event.value })
+          },
+          SET_ERROR: {
+            target: "error",
+            actions: (_ctx, event) => ({ error: event.error })
+          }
+        }
+      },
+      focused: {
+        on: {
+          BLUR: "idle",
+          CHANGE: {
+            target: "focused",
+            actions: (_ctx, event) => ({ value: event.value })
+          },
+          SET_ERROR: {
+            target: "error",
+            actions: (_ctx, event) => ({ error: event.error })
+          }
+        }
+      },
+      filled: {
+        on: {
+          FOCUS: "focused",
+          CHANGE: {
+            target: "filled",
+            actions: (_ctx, event) => ({ value: event.value })
+          },
+          CLEAR: {
+            target: "idle",
+            actions: () => ({ value: "" })
+          },
+          SET_ERROR: {
+            target: "error",
+            actions: (_ctx, event) => ({ error: event.error })
+          }
+        }
+      },
+      error: {
+        on: {
+          FOCUS: "focused",
+          CHANGE: {
+            target: "error",
+            actions: (_ctx, event) => ({ value: event.value })
+          },
+          SET_ERROR: {
+            target: "error",
+            actions: (_ctx, event) => {
+              const err = event.error;
+              return err === null ? {} : { error: err };
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+// src/machines/input/input.connect.ts
+function connectInput(options) {
+  const { state, context, send, onChange } = options;
+  const { value, disabled, readOnly, required, error, placeholder, id } = context;
+  const hasError = state === "error" || error !== null;
+  const errorId = `${id}-error`;
+  const labelId = `${id}-label`;
+  return {
+    state,
+    value,
+    hasError,
+    rootProps: {
+      "data-state": state,
+      "data-disabled": disabled ? "" : void 0
+    },
+    labelProps: {
+      id: labelId,
+      htmlFor: id
+    },
+    inputProps: {
+      id,
+      value,
+      disabled,
+      readOnly,
+      placeholder,
+      "aria-labelledby": labelId,
+      ...getAriaDisabled(disabled),
+      ...getAriaInvalid(hasError),
+      ...getAriaRequired(required),
+      ...hasError ? { "aria-describedby": errorId } : {},
+      "data-state": state,
+      onFocus: () => {
+        if (disabled) return;
+        send({ type: "FOCUS" });
+      },
+      onBlur: () => {
+        send({ type: "BLUR" });
+      },
+      onChange: (event) => {
+        if (disabled || readOnly) return;
+        const val = event && typeof event === "object" && "target" in event ? event.target.value : String(event);
+        send({ type: "CHANGE", value: val });
+        onChange?.(val);
+      }
+    },
+    errorProps: {
+      id: errorId,
+      role: "alert",
+      "aria-live": "polite",
+      style: { display: hasError ? "block" : "none" }
+    }
+  };
+}
+
+export { connectInput, createInputMachine };

package/dist/chunk-DEYVI3GG.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// src/machines/typography/typography.connect.ts
+var variantElementMap = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6",
+  body: "p",
+  body1: "p",
+  body2: "p",
+  caption: "span",
+  overline: "span"
+};
+function connectTypography(options) {
+  const { variant, align, truncate, color } = options;
+  const element = variantElementMap[variant];
+  const style = {};
+  if (align) style.textAlign = align;
+  if (color) style.color = color;
+  if (truncate) {
+    style.overflow = "hidden";
+    style.textOverflow = "ellipsis";
+    style.whiteSpace = "nowrap";
+  }
+  return {
+    element,
+    rootProps: {
+      "data-variant": variant,
+      ...Object.keys(style).length > 0 ? { style } : {}
+    }
+  };
+}
+
+exports.connectTypography = connectTypography;

package/dist/chunk-ECS4ZLAD.mjs

@@ -0,0 +1,94 @@
+import { createMachine } from './chunk-YFNMWGC7.mjs';
+
+// src/machines/modal/modal.machine.ts
+function createModalMachine(initialContext) {
+  const id = `modal-${Date.now()}`;
+  return createMachine({
+    id: "modal",
+    initial: "closed",
+    context: {
+      triggerId: `${id}-trigger`,
+      contentId: `${id}-content`,
+      titleId: `${id}-title`,
+      closeOnOverlayClick: true,
+      closeOnEscape: true,
+      trapFocus: true,
+      ...initialContext
+    },
+    states: {
+      closed: {
+        on: {
+          OPEN: "open",
+          TOGGLE: "open"
+        }
+      },
+      open: {
+        on: {
+          CLOSE: "closed",
+          TOGGLE: "closed",
+          ESCAPE: "closed",
+          OVERLAY_CLICK: "closed"
+        }
+      }
+    }
+  });
+}
+
+// src/machines/modal/modal.connect.ts
+function connectModal(options) {
+  const { state, context, send, onOpenChange } = options;
+  const { triggerId, contentId, titleId, closeOnOverlayClick, closeOnEscape } = context;
+  const isOpen = state === "open";
+  function handleOpen() {
+    send({ type: "OPEN" });
+    onOpenChange?.(true);
+  }
+  function handleClose() {
+    send({ type: "CLOSE" });
+    onOpenChange?.(false);
+  }
+  return {
+    state,
+    isOpen,
+    triggerProps: {
+      id: triggerId,
+      "aria-haspopup": "dialog",
+      "aria-expanded": isOpen,
+      "aria-controls": isOpen ? contentId : void 0,
+      onClick: handleOpen
+    },
+    contentProps: {
+      id: contentId,
+      role: "dialog",
+      "aria-modal": true,
+      "aria-labelledby": titleId,
+      "data-state": state,
+      tabIndex: -1,
+      onKeyDown: (event) => {
+        if (!closeOnEscape) return;
+        const e = event;
+        if (e.key === "Escape") {
+          handleClose();
+        }
+      }
+    },
+    overlayProps: {
+      "data-state": state,
+      "aria-hidden": true,
+      onClick: () => {
+        if (closeOnOverlayClick) {
+          handleClose();
+        }
+      }
+    },
+    closeProps: {
+      "aria-label": "Close",
+      onClick: handleClose
+    },
+    titleProps: {
+      id: titleId
+    }
+  };
+}
+
+export { connectModal, createModalMachine };

package/dist/chunk-EQR2S6TY.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var chunkYTHNCP77_js = require('./chunk-YTHNCP77.js');
+var chunkKWFE67IV_js = require('./chunk-KWFE67IV.js');
+
+// src/machines/button/button.machine.ts
+function createButtonMachine(initialContext) {
+  return chunkKWFE67IV_js.createMachine({
+    id: "button",
+    initial: "idle",
+    context: {
+      disabled: false,
+      loading: false,
+      variant: "primary",
+      size: "md",
+      ...initialContext
+    },
+    states: {
+      idle: {
+        on: {
+          PRESS: "pressed",
+          FOCUS: "focused",
+          SET_LOADING: {
+            target: "idle",
+            actions: (_ctx, event) => ({ loading: event.loading })
+          },
+          SET_DISABLED: {
+            target: "idle",
+            actions: (_ctx, event) => ({ disabled: event.disabled })
+          }
+        }
+      },
+      pressed: {
+        on: {
+          RELEASE: "idle",
+          BLUR: "idle"
+        }
+      },
+      focused: {
+        on: {
+          PRESS: "pressed",
+          BLUR: "idle"
+        }
+      }
+    }
+  });
+}
+
+// src/machines/button/button.connect.ts
+function connectButton(options) {
+  const { state, context, send, onClick } = options;
+  const { disabled, loading, variant, size } = context;
+  const isDisabled = disabled || loading;
+  return {
+    state,
+    isDisabled,
+    isLoading: loading,
+    rootProps: {
+      role: "button",
+      type: "button",
+      disabled: isDisabled,
+      "data-state": state,
+      "data-variant": variant,
+      "data-size": size,
+      ...chunkYTHNCP77_js.getAriaDisabled(isDisabled),
+      ...loading ? { "aria-busy": true } : {},
+      onClick: (event) => {
+        if (isDisabled) return;
+        onClick?.(event);
+      },
+      onPointerDown: () => {
+        if (isDisabled) return;
+        send({ type: "PRESS" });
+      },
+      onPointerUp: () => {
+        if (isDisabled) return;
+        send({ type: "RELEASE" });
+      },
+      onFocus: () => {
+        if (isDisabled) return;
+        send({ type: "FOCUS" });
+      },
+      onBlur: () => {
+        send({ type: "BLUR" });
+      }
+    },
+    loadingProps: {
+      "aria-hidden": true,
+      style: {
+        display: loading ? "inline-flex" : "none"
+      }
+    }
+  };
+}
+
+exports.connectButton = connectButton;
+exports.createButtonMachine = createButtonMachine;

package/dist/chunk-IRJ3PEU4.mjs

@@ -0,0 +1,35 @@
+// src/utils/accessibility.ts
+function getAriaDisabled(disabled) {
+  if (!disabled) return {};
+  return {
+    "aria-disabled": true,
+    "data-disabled": ""
+  };
+}
+function getAriaPressed(pressed) {
+  return { "aria-pressed": pressed };
+}
+function getAriaExpanded(expanded) {
+  return { "aria-expanded": expanded };
+}
+function getAriaInvalid(invalid) {
+  return { "aria-invalid": invalid };
+}
+function getAriaRequired(required) {
+  return { "aria-required": required };
+}
+function getAriaModal() {
+  return {
+    "aria-modal": true,
+    role: "dialog"
+  };
+}
+var idCounter = 0;
+function generateId(prefix) {
+  return `${prefix}-${++idCounter}`;
+}
+function resetIdCounter() {
+  idCounter = 0;
+}
+
+export { generateId, getAriaDisabled, getAriaExpanded, getAriaInvalid, getAriaModal, getAriaPressed, getAriaRequired, resetIdCounter };

package/dist/chunk-JTKA5LGK.mjs

@@ -0,0 +1,35 @@
+// src/machines/typography/typography.connect.ts
+var variantElementMap = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6",
+  body: "p",
+  body1: "p",
+  body2: "p",
+  caption: "span",
+  overline: "span"
+};
+function connectTypography(options) {
+  const { variant, align, truncate, color } = options;
+  const element = variantElementMap[variant];
+  const style = {};
+  if (align) style.textAlign = align;
+  if (color) style.color = color;
+  if (truncate) {
+    style.overflow = "hidden";
+    style.textOverflow = "ellipsis";
+    style.whiteSpace = "nowrap";
+  }
+  return {
+    element,
+    rootProps: {
+      "data-variant": variant,
+      ...Object.keys(style).length > 0 ? { style } : {}
+    }
+  };
+}
+
+export { connectTypography };

package/dist/chunk-KQF35W7O.mjs

@@ -0,0 +1,32 @@
+// src/machines/card/card.connect.ts
+function connectCard(options = {}) {
+  const { variant = "elevated", padding = "md", interactive = false, onClick } = options;
+  return {
+    rootProps: {
+      "data-variant": variant,
+      "data-padding": padding,
+      ...interactive ? {
+        role: "button",
+        tabIndex: 0,
+        onClick,
+        onKeyDown: (event) => {
+          const e = event;
+          if (e.key === "Enter" || e.key === " ") {
+            onClick?.(event);
+          }
+        }
+      } : {}
+    },
+    headerProps: {
+      "data-part": "header"
+    },
+    bodyProps: {
+      "data-part": "body"
+    },
+    footerProps: {
+      "data-part": "footer"
+    }
+  };
+}
+
+export { connectCard };

package/dist/chunk-KWFE67IV.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// src/create-machine.ts
+function createMachine(config) {
+  let currentState = config.initial;
+  let context = { ...config.context };
+  let snapshot = { state: currentState, context };
+  const listeners = /* @__PURE__ */ new Set();
+  let running = false;
+  function updateSnapshot() {
+    snapshot = { state: currentState, context };
+  }
+  function notify() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  return {
+    send(event) {
+      if (!running) return;
+      const stateConfig = config.states[currentState];
+      if (!stateConfig?.on) return;
+      const transition = stateConfig.on[event.type];
+      if (!transition) return;
+      if (typeof transition === "string") {
+        currentState = transition;
+      } else {
+        const t = transition;
+        currentState = t.target;
+        if (t.actions) {
+          context = { ...context, ...t.actions(context, event) };
+        }
+      }
+      updateSnapshot();
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    start() {
+      running = true;
+    },
+    stop() {
+      running = false;
+      listeners.clear();
+    }
+  };
+}
+
+exports.createMachine = createMachine;