@lostgradient/cinder 0.1.0 → 0.2.0

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

@@ -0,0 +1,103 @@
+import { createRequire } from "node:module";
+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 __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/components/choice-grid/choice-grid.schema.ts
+var schema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    value: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      description: "The currently selected value (single-select mode). Bindable.\nPass `null` or omit to start with no selection."
+    },
+    values: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      description: "Currently selected values (multi-select mode). Bindable. Only used when\n`multiple` is `true` — set `multiple` explicitly to switch modes; binding\n`values` alone does NOT enable multi-select."
+    },
+    multiple: {
+      type: "boolean",
+      description: "When true the grid allows multiple simultaneous selections and reads/writes\n`values` instead of `value`. The ARIA role switches to `group` (items become\n`checkbox`); single-select uses `radiogroup` (items become `radio`)."
+    },
+    columns: {
+      enum: ["responsive", 1, 2, 3, 4],
+      description: "Column layout.\n- `'responsive'` — `auto-fill` at a minimum cell width (default).\n- `1 | 2 | 3 | 4` — fixed number of columns."
+    },
+    minColumnWidth: {
+      type: "string",
+      description: 'Minimum cell width for `columns="responsive"`. Accepts any CSS\n`<length>` (e.g. `"12rem"`, `"200px"`). Default: `"10rem"`.'
+    },
+    ariaLabel: {
+      type: "string",
+      description: "Accessible label for the grid (required unless `ariaLabelledby` is set)."
+    },
+    ariaLabelledby: {
+      type: "string",
+      description: "Id of an external element that labels this grid."
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disables all items in the grid."
+    }
+  },
+  additionalProperties: false,
+  metadata: {
+    unsupportedProps: [
+      {
+        name: "children",
+        reason: "function-or-snippet"
+      },
+      {
+        name: "class",
+        reason: "unknown-shape"
+      }
+    ]
+  }
+};
+var choice_grid_schema_default = schema;
+export {
+  choice_grid_schema_default as default
+};
+
+//# debugId=6D40065DDC5A5BC364756E2164756E21

package/dist/server/components/choice-grid/choice-grid.variables.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+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 __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/components/choice-grid/choice-grid.variables.ts
+var variables = [];
+var choice_grid_variables_default = variables;
+export {
+  choice_grid_variables_default as default
+};
+
+//# debugId=B64A023B7D966B6064756E2164756E21

package/dist/server/components/choice-grid/index.css

@@ -0,0 +1,103 @@
+/* src/components/choice-grid-item/choice-grid-item.css */
+@layer cinder.tokens, cinder.foundation, cinder.components, cinder.utilities;
+
+@layer cinder.components {
+  .cinder-choice-grid-item {
+    display: flex;
+    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;
+    outline: none;
+    touch-action: manipulation;
+    justify-content: center;
+    align-items:  center;
+    min-block-size: 4rem;
+    transition: background .12s, border-color .12s, box-shadow .12s;
+  }
+
+  .cinder-choice-grid-item__content {
+    display: inline-flex;
+    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;
+    flex-direction: column;
+  }
+
+  @media (hover: hover) {
+    .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);
+    }
+  }
+
+  .cinder-choice-grid-item:focus-visible {
+    border-color: var(--cinder-accent);
+    box-shadow: var(--_cinder-focus-ring-shadow);
+  }
+
+  @media (forced-colors: active) {
+    .cinder-choice-grid-item:focus-visible {
+      outline: var(--cinder-ring-width) solid ButtonText;
+      outline-offset: 2px;
+    }
+  }
+
+  .cinder-choice-grid-item[data-cinder-selected] {
+    border-color: var(--cinder-accent);
+    color: var(--cinder-accent-text);
+  }
+
+  @media (hover: hover) {
+    .cinder-choice-grid-item[data-cinder-selected]:not([data-cinder-disabled]):not([data-cinder-state]):hover {
+      border-color: var(--cinder-accent-hover);
+    }
+  }
+
+  .cinder-choice-grid-item[data-cinder-disabled] {
+    cursor: not-allowed;
+    opacity: .45;
+  }
+
+  .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);
+  }
+
+  .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);
+  }
+
+  .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);
+  }
+}
+
+/* src/components/choice-grid/choice-grid.css */
+@layer cinder.tokens, cinder.foundation, cinder.components, cinder.utilities;
+
+@layer cinder.components {
+  .cinder-choice-grid {
+    display: grid;
+    grid-template-columns: var(--cinder-choice-grid-columns, repeat(auto-fill, minmax(min(10rem, 100%), 1fr)));
+    gap: var(--cinder-space-3);
+    inline-size: 100%;
+  }
+
+  .cinder-choice-grid[data-cinder-disabled] {
+    opacity: .6;
+    pointer-events: none;
+  }
+}

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

@@ -0,0 +1,383 @@
+import { createRequire } from "node:module";
+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 __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/components/choice-grid-item/choice-grid-item.svelte
+import * as $ from "svelte/internal/server";
+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/false.js
+var false_default = false;
+// ../../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
+function Choice_grid_item($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const ITEM_STATES = ["neutral", "correct", "incorrect", "pending"];
+    let {
+      value,
+      state: stateProp = "neutral",
+      disabled = false,
+      class: className,
+      children
+    } = $$props;
+    const feedbackState = $.derived(() => ITEM_STATES.includes(stateProp) ? stateProp : "neutral");
+    const context = getChoiceGridContext();
+    const registeredValue = untrack(() => value);
+    const isSelected = $.derived(() => context.isSelected(registeredValue));
+    const isDisabled = $.derived(() => disabled || context.disabled);
+    const isFocusable = $.derived(() => context.isFocusable(registeredValue));
+    const tabIndex = $.derived(() => rovingTabIndex(isFocusable()));
+    const role = $.derived(() => context.multiple ? "checkbox" : "radio");
+    let elementRef = null;
+    function handleClick() {
+      if (isDisabled())
+        return;
+      context.select(registeredValue);
+    }
+    function handleKeydown(event) {
+      context.handleKeydown(event);
+    }
+    $$renderer2.push(`<div${$.attr("role", role())}${$.attr("aria-checked", isSelected())}${$.attr("aria-disabled", isDisabled() || undefined)}${$.attr("tabindex", tabIndex())}${$.attr_class($.clsx(classNames("cinder-choice-grid-item", className)))}${$.attr("data-cinder-selected", isSelected() || undefined)}${$.attr("data-cinder-disabled", isDisabled() || undefined)}${$.attr("data-cinder-state", feedbackState() !== "neutral" ? feedbackState() : undefined)}><span class="cinder-choice-grid-item__content">`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></span></div>`);
+  });
+}
+
+// src/components/choice-grid/choice-grid.svelte
+import * as $2 from "svelte/internal/server";
+
+// 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
+function Choice_grid($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      value = null,
+      values = [],
+      multiple = false,
+      columns = "responsive",
+      minColumnWidth = "10rem",
+      ariaLabel,
+      ariaLabelledby,
+      disabled = false,
+      class: className,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const items = new Map;
+    let version = 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 multiSelection().isSelected(candidate);
+      }
+      return singleSelection().isSelected(candidate);
+    }
+    function select(candidate) {
+      if (isItemDisabled(candidate))
+        return;
+      if (multiple) {
+        multiSelection().toggle(candidate);
+      } else {
+        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(() => {
+      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) {
+      return focusableValue() === candidate;
+    }
+    function register(itemValue, element, itemDisabled) {
+      items.set(itemValue, { element, disabled: itemDisabled });
+      version += 1;
+    }
+    function setItemDisabled(itemValue, itemDisabled) {
+      const existing = items.get(itemValue);
+      if (existing && existing.disabled !== itemDisabled) {
+        items.set(itemValue, { element: existing.element, disabled: itemDisabled });
+        version += 1;
+      }
+    }
+    function unregister(itemValue) {
+      if (items.delete(itemValue)) {
+        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(() => ariaLabel?.trim() ? ariaLabel : undefined);
+    const resolvedAriaLabelledby = $2.derived(() => ariaLabelledby?.trim() ? ariaLabelledby : undefined);
+    const gridTemplateColumns = $2.derived(() => columns === "responsive" ? `repeat(auto-fill, minmax(min(${minColumnWidth}, 100%), 1fr))` : `repeat(${columns}, 1fr)`);
+    const role = $2.derived(() => multiple ? "group" : "radiogroup");
+    $$renderer2.push(`<div${$2.attributes({
+      ...rest,
+      role: role(),
+      class: $2.clsx(classNames("cinder-choice-grid", className)),
+      "aria-label": resolvedAriaLabel(),
+      "aria-labelledby": resolvedAriaLabelledby(),
+      "aria-disabled": disabled || undefined,
+      "data-cinder-multiple": multiple || undefined,
+      "data-cinder-disabled": disabled || undefined
+    }, undefined, undefined, { "--cinder-choice-grid-columns": gridTemplateColumns() })}>`);
+    children($$renderer2);
+    $$renderer2.push(`<!----></div>`);
+    $2.bind_props($$props, { value, values });
+  });
+}
+
+// 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=D100FB31D0A80F4364756E2164756E21

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

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+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 __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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=D771EB956DAD9C9564756E2164756E21