@lostgradient/cinder 0.1.1 → 0.2.0

package/dist/components/choice-grid/index.js

@@ -0,0 +1,466 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/choice-grid/index.ts
+import"@lostgradient/cinder/choice-grid/styles";
+
+// src/components/choice-grid-item/choice-grid-item.svelte
+import"svelte/internal/disclose-version";
+import * as $ from "svelte/internal/client";
+import { untrack } from "svelte";
+
+// src/components/choice-grid/choice-grid-context.ts
+import { createContext } from "svelte";
+var [getChoiceGridContextStrict, setChoiceGridContext] = createContext();
+var getChoiceGridContext = getChoiceGridContextStrict;
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// src/_internal/collection.ts
+function createSingleSelection(getValue, setValue) {
+  return {
+    get value() {
+      return getValue();
+    },
+    select(next) {
+      setValue(next);
+    },
+    isSelected(candidate) {
+      return getValue() === candidate;
+    }
+  };
+}
+function createMultiSelection(getValues, setValues) {
+  return {
+    get values() {
+      return getValues();
+    },
+    toggle(item) {
+      const current = getValues();
+      const index = current.indexOf(item);
+      if (index === -1) {
+        setValues([...current, item]);
+      } else {
+        setValues(current.filter((existing) => existing !== item));
+      }
+    },
+    isSelected(candidate) {
+      return getValues().includes(candidate);
+    }
+  };
+}
+function rovingTabIndex(isActive) {
+  return isActive ? 0 : -1;
+}
+
+// ../../node_modules/esm-env/true.js
+var true_default = true;
+// src/utilities/dev-warn.ts
+function devWarn(message, ...args) {
+  if (!true_default)
+    return;
+  console.warn(message, ...args);
+}
+
+// src/components/choice-grid-item/choice-grid-item.svelte
+var root = $.from_html(`<div><span class="cinder-choice-grid-item__content"><!></span></div>`);
+function Choice_grid_item($$anchor, $$props) {
+  $.push($$props, true);
+  const ITEM_STATES = ["neutral", "correct", "incorrect", "pending"];
+  let stateProp = $.prop($$props, "state", 3, "neutral"), disabled = $.prop($$props, "disabled", 3, false);
+  const feedbackState = $.derived(() => ITEM_STATES.includes(stateProp()) ? stateProp() : "neutral");
+  $.user_effect(() => {
+    if (!ITEM_STATES.includes(stateProp())) {
+      devWarn(`ChoiceGridItem: invalid state "${String(stateProp())}". Expected one of ${ITEM_STATES.join(", ")}. Falling back to "neutral".`);
+    }
+  });
+  const context = getChoiceGridContext();
+  const registeredValue = untrack(() => $$props.value);
+  $.user_effect(() => {
+    if ($$props.value !== registeredValue) {
+      devWarn(`ChoiceGridItem: \`value\` changed from "${registeredValue}" to "${$$props.value}" after mount. ChoiceGridItem.value must be stable — give the item a fixed value (use {#key} to remount if the value must change). The grid keeps using the original value.`);
+    }
+  });
+  const isSelected = $.derived(() => context.isSelected(registeredValue));
+  const isDisabled = $.derived(() => disabled() || context.disabled);
+  const isFocusable = $.derived(() => context.isFocusable(registeredValue));
+  const tabIndex = $.derived(() => rovingTabIndex($.get(isFocusable)));
+  const role = $.derived(() => context.multiple ? "checkbox" : "radio");
+  let elementRef = $.state(null);
+  $.user_effect(() => {
+    const el = $.get(elementRef);
+    if (!el)
+      return;
+    untrack(() => {
+      context.register(registeredValue, el, $.get(isDisabled));
+    });
+    return () => {
+      untrack(() => {
+        context.unregister(registeredValue);
+      });
+    };
+  });
+  $.user_effect(() => {
+    const nextDisabled = $.get(isDisabled);
+    untrack(() => {
+      context.setItemDisabled(registeredValue, nextDisabled);
+    });
+  });
+  function handleClick() {
+    if ($.get(isDisabled))
+      return;
+    context.select(registeredValue);
+  }
+  function handleKeydown(event) {
+    context.handleKeydown(event);
+  }
+  var div = root();
+  var span = $.child(div);
+  var node = $.child(span);
+  $.snippet(node, () => $$props.children);
+  $.reset(span);
+  $.reset(div);
+  $.bind_this(div, ($$value) => $.set(elementRef, $$value), () => $.get(elementRef));
+  $.template_effect(($0) => {
+    $.set_attribute(div, "role", $.get(role));
+    $.set_attribute(div, "aria-checked", $.get(isSelected));
+    $.set_attribute(div, "aria-disabled", $.get(isDisabled) || undefined);
+    $.set_attribute(div, "tabindex", $.get(tabIndex));
+    $.set_class(div, 1, $0);
+    $.set_attribute(div, "data-cinder-selected", $.get(isSelected) || undefined);
+    $.set_attribute(div, "data-cinder-disabled", $.get(isDisabled) || undefined);
+    $.set_attribute(div, "data-cinder-state", $.get(feedbackState) !== "neutral" ? $.get(feedbackState) : undefined);
+  }, [
+    () => $.clsx(classNames("cinder-choice-grid-item", $$props.class))
+  ]);
+  $.delegated("click", div, handleClick);
+  $.delegated("keydown", div, handleKeydown);
+  $.append($$anchor, div);
+  $.pop();
+}
+$.delegate(["click", "keydown"]);
+
+// src/components/choice-grid/choice-grid.svelte
+import"svelte/internal/disclose-version";
+import * as $2 from "svelte/internal/client";
+
+// src/utilities/roving-tabindex.ts
+var ROVING_KEYS = new Set(["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"]);
+function isRovingKey(key) {
+  return ROVING_KEYS.has(key);
+}
+function findNextIndex(currentIndex, length, direction, isDisabled) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled) {
+    return (currentIndex + direction + length) % length;
+  }
+  for (let offset = 1;offset <= length; offset += 1) {
+    const candidateIndex = (currentIndex + offset * direction + length * offset) % length;
+    if (!isDisabled(candidateIndex)) {
+      return candidateIndex;
+    }
+  }
+  return currentIndex;
+}
+function findFirstIndex(length, isDisabled, currentIndex = 0) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled)
+    return 0;
+  for (let index = 0;index < length; index += 1) {
+    if (!isDisabled(index))
+      return index;
+  }
+  return currentIndex;
+}
+function findLastIndex(length, isDisabled, currentIndex = 0) {
+  if (length === 0)
+    return -1;
+  if (!isDisabled)
+    return length - 1;
+  for (let index = length - 1;index >= 0; index -= 1) {
+    if (!isDisabled(index))
+      return index;
+  }
+  return currentIndex;
+}
+function handleRovingKeydown(event, currentIndex, length, options = {}) {
+  const { isDisabled, vertical = true, horizontal = true } = options;
+  if (length === 0)
+    return null;
+  switch (event.key) {
+    case "ArrowRight":
+      return horizontal ? findNextIndex(currentIndex, length, 1, isDisabled) : null;
+    case "ArrowDown":
+      return vertical ? findNextIndex(currentIndex, length, 1, isDisabled) : null;
+    case "ArrowLeft":
+      return horizontal ? findNextIndex(currentIndex, length, -1, isDisabled) : null;
+    case "ArrowUp":
+      return vertical ? findNextIndex(currentIndex, length, -1, isDisabled) : null;
+    case "Home":
+      return findFirstIndex(length, isDisabled, currentIndex);
+    case "End":
+      return findLastIndex(length, isDisabled, currentIndex);
+    default:
+      return null;
+  }
+}
+function getFocusableIndex(selectedIndex, length, isDisabled) {
+  if (length === 0)
+    return -1;
+  if (selectedIndex >= 0 && selectedIndex < length)
+    return selectedIndex;
+  return findFirstIndex(length, isDisabled, 0);
+}
+
+// src/components/choice-grid/choice-grid.svelte
+var root2 = $2.from_html(`<div><!></div>`);
+function Choice_grid($$anchor, $$props) {
+  $2.push($$props, true);
+  let value = $2.prop($$props, "value", 15, null), values = $2.prop($$props, "values", 31, () => $2.proxy([])), multiple = $2.prop($$props, "multiple", 3, false), columns = $2.prop($$props, "columns", 3, "responsive"), minColumnWidth = $2.prop($$props, "minColumnWidth", 3, "10rem"), disabled = $2.prop($$props, "disabled", 3, false), rest = $2.rest_props($$props, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "value",
+    "values",
+    "multiple",
+    "columns",
+    "minColumnWidth",
+    "ariaLabel",
+    "ariaLabelledby",
+    "disabled",
+    "class",
+    "children"
+  ]);
+  const items = new Map;
+  let version = $2.state(0);
+  const singleSelection = $2.derived(() => createSingleSelection(() => value() ?? null, (next) => {
+    value(next);
+  }));
+  const multiSelection = $2.derived(() => createMultiSelection(() => values(), (next) => {
+    values(next);
+  }));
+  function isSelected(candidate) {
+    if (multiple()) {
+      return $2.get(multiSelection).isSelected(candidate);
+    }
+    return $2.get(singleSelection).isSelected(candidate);
+  }
+  function select(candidate) {
+    if (isItemDisabled(candidate))
+      return;
+    if (multiple()) {
+      $2.get(multiSelection).toggle(candidate);
+    } else {
+      $2.get(singleSelection).select(candidate);
+    }
+  }
+  function isItemDisabled(candidate) {
+    if (disabled())
+      return true;
+    return items.get(candidate)?.disabled ?? false;
+  }
+  function orderedKeys() {
+    return [...items.entries()].sort(([, a], [, b]) => {
+      const position = a.element.compareDocumentPosition(b.element);
+      if (position & Node.DOCUMENT_POSITION_FOLLOWING)
+        return -1;
+      if (position & Node.DOCUMENT_POSITION_PRECEDING)
+        return 1;
+      return 0;
+    }).map(([key]) => key);
+  }
+  const focusableValue = $2.derived(() => {
+    $2.get(version);
+    value();
+    values();
+    const ordered = orderedKeys();
+    if (ordered.length === 0)
+      return null;
+    if (!multiple() && value() !== null && value() !== undefined) {
+      if (items.has(value()) && !isItemDisabled(value()))
+        return value();
+    }
+    if (multiple() && values().length > 0) {
+      for (const selected of values()) {
+        if (items.has(selected) && !isItemDisabled(selected))
+          return selected;
+      }
+    }
+    for (const key of ordered) {
+      if (!isItemDisabled(key))
+        return key;
+    }
+    return null;
+  });
+  function isFocusable(candidate) {
+    $2.get(version);
+    value();
+    values();
+    return $2.get(focusableValue) === candidate;
+  }
+  function register(itemValue, element, itemDisabled) {
+    items.set(itemValue, { element, disabled: itemDisabled });
+    $2.set(version, $2.get(version) + 1);
+  }
+  function setItemDisabled(itemValue, itemDisabled) {
+    const existing = items.get(itemValue);
+    if (existing && existing.disabled !== itemDisabled) {
+      items.set(itemValue, { element: existing.element, disabled: itemDisabled });
+      $2.set(version, $2.get(version) + 1);
+    }
+  }
+  function unregister(itemValue) {
+    if (items.delete(itemValue)) {
+      $2.set(version, $2.get(version) + 1);
+    }
+  }
+  function handleKeydown(event) {
+    const keys = orderedKeys();
+    const currentIndex = keys.findIndex((key) => {
+      const entry = items.get(key);
+      return entry?.element === event.currentTarget || entry?.element === event.target;
+    });
+    if (currentIndex === -1)
+      return;
+    if (event.key === " " || event.key === "Enter") {
+      event.preventDefault();
+      const focusedValue = keys[currentIndex];
+      if (focusedValue !== undefined) {
+        select(focusedValue);
+      }
+      return;
+    }
+    const nextIndex = handleRovingKeydown(event, currentIndex, keys.length, {
+      horizontal: true,
+      vertical: true,
+      isDisabled: (index) => {
+        const key = keys[index];
+        return key === undefined ? true : isItemDisabled(key);
+      }
+    });
+    if (nextIndex === null || nextIndex === currentIndex)
+      return;
+    event.preventDefault();
+    const nextValue = keys[nextIndex];
+    if (nextValue === undefined)
+      return;
+    items.get(nextValue)?.element.focus();
+    if (!multiple()) {
+      select(nextValue);
+    }
+  }
+  setChoiceGridContext({
+    get value() {
+      return value() ?? null;
+    },
+    get multiple() {
+      return multiple();
+    },
+    get disabled() {
+      return disabled();
+    },
+    isSelected,
+    select,
+    register,
+    setItemDisabled,
+    unregister,
+    isFocusable,
+    handleKeydown
+  });
+  const resolvedAriaLabel = $2.derived(() => $$props.ariaLabel?.trim() ? $$props.ariaLabel : undefined);
+  const resolvedAriaLabelledby = $2.derived(() => $$props.ariaLabelledby?.trim() ? $$props.ariaLabelledby : undefined);
+  $2.user_effect(() => {
+    if (values().length > 0 && !multiple()) {
+      devWarn("ChoiceGrid: `values` was provided without `multiple`. Binding `values` does not enable multi-select — set `multiple` explicitly. The grid is operating in single-select mode and ignoring `values`.");
+    }
+    if (!$2.get(resolvedAriaLabel) && !$2.get(resolvedAriaLabelledby)) {
+      devWarn("ChoiceGrid: no `ariaLabel` or `ariaLabelledby` provided. The radiogroup/group has no accessible name — pass one.");
+    }
+  });
+  const gridTemplateColumns = $2.derived(() => columns() === "responsive" ? `repeat(auto-fill, minmax(min(${minColumnWidth()}, 100%), 1fr))` : `repeat(${columns()}, 1fr)`);
+  const role = $2.derived(() => multiple() ? "group" : "radiogroup");
+  var div = root2();
+  $2.attribute_effect(div, ($0) => ({
+    ...rest,
+    role: $2.get(role),
+    class: $0,
+    "aria-label": $2.get(resolvedAriaLabel),
+    "aria-labelledby": $2.get(resolvedAriaLabelledby),
+    "aria-disabled": disabled() || undefined,
+    "data-cinder-multiple": multiple() || undefined,
+    "data-cinder-disabled": disabled() || undefined,
+    [$2.STYLE]: { "--cinder-choice-grid-columns": $2.get(gridTemplateColumns) }
+  }), [() => classNames("cinder-choice-grid", $$props.class)]);
+  var node = $2.child(div);
+  $2.snippet(node, () => $$props.children);
+  $2.reset(div);
+  $2.append($$anchor, div);
+  $2.pop();
+}
+
+// src/components/choice-grid/index.ts
+var ChoiceGrid = Object.assign(Choice_grid, {
+  Item: Choice_grid_item
+});
+var choice_grid_default = ChoiceGrid;
+export {
+  choice_grid_default as default,
+  ChoiceGrid
+};
+
+//# debugId=A8F6659998F81BBE64756E2164756E21

package/dist/components/choice-grid-item/choice-grid-item.css

@@ -0,0 +1,139 @@
+@layer cinder.tokens, cinder.foundation, cinder.components, cinder.utilities;
+
+@layer cinder.components {
+  /* ========================================
+   * CHOICE GRID ITEM — selectable answer tile
+   * ======================================== */
+
+  .cinder-choice-grid-item {
+    /* Stable sizing: min-height ensures cells never shrink when feedback state
+     * text/icons appear. Width is determined by the parent grid track. */
+    min-block-size: 4rem;
+
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: var(--cinder-space-4) var(--cinder-space-3);
+    border-radius: var(--cinder-radius-lg);
+    border: 2px solid var(--cinder-border-muted);
+    background: var(--cinder-surface);
+    color: var(--cinder-text);
+    cursor: pointer;
+    user-select: none;
+    transition:
+      background 120ms ease,
+      border-color 120ms ease,
+      box-shadow 120ms ease;
+    outline: none; /* Focus ring provided via box-shadow below. */
+
+    /* Touch target: ensure at least 44px for mobile accessibility. */
+    touch-action: manipulation;
+  }
+
+  /* Item content wrapper — prevents the flex alignment from collapsing the
+   * children when they are shorter than the min-height baseline. */
+  .cinder-choice-grid-item__content {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: center;
+    gap: var(--cinder-space-1);
+    font-size: var(--cinder-text-base);
+    font-weight: var(--cinder-font-medium);
+    line-height: var(--cinder-leading-snug);
+    pointer-events: none; /* Clicks bubble to the item div. */
+  }
+
+  /* ----------------------------------------
+   * Hover (non-touch devices only)
+   * ---------------------------------------- */
+
+  @media (hover: hover) {
+    /* Neutral hover only. Excludes selected and graded (correct/incorrect/
+     * pending) tiles so their accent/feedback colors aren't clobbered to a
+     * neutral raised fill on hover — those states own their own hover rules
+     * (or intentionally stay flat). */
+    .cinder-choice-grid-item:not([data-cinder-disabled]):not([data-cinder-selected]):not(
+        [data-cinder-state]
+      ):hover {
+      border-color: var(--cinder-border);
+      background: var(--cinder-surface-raised);
+    }
+  }
+
+  /* ----------------------------------------
+   * Focus ring
+   * ---------------------------------------- */
+
+  .cinder-choice-grid-item:focus-visible {
+    border-color: var(--cinder-accent);
+    box-shadow: var(--_cinder-focus-ring-shadow);
+  }
+
+  /* Forced Colors Mode — box-shadow rings are invisible; use a real outline. */
+  @media (forced-colors: active) {
+    .cinder-choice-grid-item:focus-visible {
+      outline: var(--cinder-ring-width) solid ButtonText;
+      outline-offset: 2px;
+    }
+  }
+
+  /* ----------------------------------------
+   * Selected state
+   * ---------------------------------------- */
+
+  /* Selected uses accent border + accent text with no filled background,
+   * matching the segmented-control convention. */
+  .cinder-choice-grid-item[data-cinder-selected] {
+    border-color: var(--cinder-accent);
+    color: var(--cinder-accent-text);
+  }
+
+  @media (hover: hover) {
+    /* Excludes graded tiles (a wrong pick can be both selected AND
+     * data-cinder-state) so hover doesn't flip their feedback border to accent
+     * — the feedback border must keep dominating on hover as it does at rest.
+     * Mirrors the neutral-hover guard above. */
+    .cinder-choice-grid-item[data-cinder-selected]:not([data-cinder-disabled]):not(
+        [data-cinder-state]
+      ):hover {
+      border-color: var(--cinder-accent-hover);
+    }
+  }
+
+  /* ----------------------------------------
+   * Disabled state
+   * ---------------------------------------- */
+
+  .cinder-choice-grid-item[data-cinder-disabled] {
+    cursor: not-allowed;
+    opacity: 0.45;
+  }
+
+  /* ----------------------------------------
+   * Feedback states — correct / incorrect / pending
+   * Dimensions are IDENTICAL to the neutral state (stable cell sizing guarantee).
+   * Only color / border / text change.
+   * ---------------------------------------- */
+
+  /* Correct */
+  .cinder-choice-grid-item[data-cinder-state='correct'] {
+    border-color: var(--cinder-color-success-border);
+    background: var(--cinder-color-success-bg);
+    color: var(--cinder-color-success-fg);
+  }
+
+  /* Incorrect */
+  .cinder-choice-grid-item[data-cinder-state='incorrect'] {
+    border-color: var(--cinder-color-danger-border);
+    background: var(--cinder-color-danger-bg);
+    color: var(--cinder-color-danger-fg);
+  }
+
+  /* Pending */
+  .cinder-choice-grid-item[data-cinder-state='pending'] {
+    border-color: var(--cinder-color-warning-border);
+    background: var(--cinder-color-warning-bg);
+    color: var(--cinder-color-warning-fg);
+  }
+}

package/dist/components/choice-grid-item/choice-grid-item.schema.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentSchema } from '../../schema-types';
+declare const _default: ComponentSchema;
+export default _default;

package/dist/components/choice-grid-item/choice-grid-item.schema.js

@@ -0,0 +1,93 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/choice-grid-item/choice-grid-item.schema.ts
+var schema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      description: `The value this item represents. Used as the key for selection state,
+roving tabindex registration, and ARIA attributes.`
+    },
+    state: {
+      enum: ["neutral", "correct", "incorrect", "pending"],
+      description: "Feedback state for assessment / quiz usage. Defaults to `'neutral'`.\nLayout dimensions do NOT change across states (stable cell sizing guarantee)."
+    },
+    disabled: {
+      type: "boolean",
+      description: "When true this item cannot be selected or focused."
+    },
+    class: {
+      type: "string",
+      description: "Additional class names merged with `.cinder-choice-grid-item`."
+    }
+  },
+  additionalProperties: false,
+  required: ["value"],
+  metadata: {
+    unsupportedProps: [
+      {
+        name: "children",
+        reason: "function-or-snippet"
+      }
+    ]
+  }
+};
+var choice_grid_item_schema_default = schema;
+export {
+  choice_grid_item_schema_default as default
+};
+
+//# debugId=C7CE5110E8CEB14C64756E2164756E21