@cruglobal/cornerstone-components 0.1.3 → 0.6.1

package/dist/unbundled/chunks/chunk.SWZMGMJM.js

@@ -0,0 +1,338 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/components/time-input/internal/time-segments.ts
+var layoutCache = /* @__PURE__ */ new Map();
+function clearTimeSegmentLayoutCache() {
+  layoutCache.clear();
+}
+function buildTimeSegmentLayout(locale, opts) {
+  const key = `${locale || "en"}|${opts.hour12 ? 12 : 24}|${opts.withSeconds ? 1 : 0}`;
+  const cached = layoutCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const formatter = new Intl.DateTimeFormat(locale || "en", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: opts.withSeconds ? "2-digit" : void 0,
+    hour12: opts.hour12,
+    calendar: "gregory",
+    numberingSystem: "latn"
+  });
+  const probeDate = new Date(2026, 0, 1, 13, 45, 30);
+  const parts = formatter.formatToParts(probeDate);
+  const tokens = [];
+  const order = [];
+  for (const part of parts) {
+    if (part.type === "hour") {
+      tokens.push({ kind: "segment", field: "hour" });
+      order.push("hour");
+    } else if (part.type === "minute") {
+      tokens.push({ kind: "segment", field: "minute" });
+      order.push("minute");
+    } else if (part.type === "second") {
+      tokens.push({ kind: "segment", field: "second" });
+      order.push("second");
+    } else if (part.type === "dayPeriod") {
+      tokens.push({ kind: "segment", field: "dayPeriod" });
+      order.push("dayPeriod");
+    } else if (part.type === "literal") {
+      tokens.push({ kind: "literal", text: part.value });
+    }
+  }
+  const expectedSegments = 2 + (opts.withSeconds ? 1 : 0) + (opts.hour12 ? 1 : 0);
+  if (order.length !== expectedSegments) {
+    const fallbackTokens = [
+      { kind: "segment", field: "hour" },
+      { kind: "literal", text: ":" },
+      { kind: "segment", field: "minute" }
+    ];
+    const fallbackOrder = ["hour", "minute"];
+    if (opts.withSeconds) {
+      fallbackTokens.push({ kind: "literal", text: ":" });
+      fallbackTokens.push({ kind: "segment", field: "second" });
+      fallbackOrder.push("second");
+    }
+    if (opts.hour12) {
+      fallbackTokens.push({ kind: "literal", text: " " });
+      fallbackTokens.push({ kind: "segment", field: "dayPeriod" });
+      fallbackOrder.push("dayPeriod");
+    }
+    const fallback = { tokens: fallbackTokens, order: fallbackOrder };
+    layoutCache.set(key, fallback);
+    return fallback;
+  }
+  const layout = { tokens, order };
+  layoutCache.set(key, layout);
+  return layout;
+}
+function resolveHour12(locale) {
+  try {
+    const probe = new Intl.DateTimeFormat(locale || "en", { hour: "numeric" });
+    return probe.resolvedOptions().hour12 ?? false;
+  } catch {
+    return false;
+  }
+}
+function formatDayPeriod(locale, period) {
+  try {
+    const formatter = new Intl.DateTimeFormat(locale || "en", { hour: "numeric", hour12: true });
+    const date = new Date(2026, 0, 1, period === 0 ? 9 : 15);
+    const parts = formatter.formatToParts(date);
+    const dp = parts.find((p) => p.type === "dayPeriod");
+    return dp?.value || (period === 0 ? "AM" : "PM");
+  } catch {
+    return period === 0 ? "AM" : "PM";
+  }
+}
+function timeSegmentBounds(field, hour12) {
+  if (field === "hour") {
+    return hour12 ? { min: 1, max: 12 } : { min: 0, max: 23 };
+  }
+  if (field === "minute" || field === "second") {
+    return { min: 0, max: 59 };
+  }
+  return { min: 0, max: 1 };
+}
+function stepTimeSegment(segments, field, delta, hour12, now = /* @__PURE__ */ new Date()) {
+  const next = { ...segments };
+  const current = segments[field];
+  if (field === "dayPeriod") {
+    const seed = current == null ? now.getHours() < 12 ? 0 : 1 : current;
+    next.dayPeriod = seed === 0 ? 1 : 0;
+    return next;
+  }
+  const { min, max } = timeSegmentBounds(field, hour12);
+  if (current == null) {
+    if (field === "hour") {
+      const h24 = now.getHours();
+      next.hour = hour12 ? h24 % 12 || 12 : h24;
+    } else if (field === "minute") {
+      next.minute = now.getMinutes();
+    } else {
+      next.second = now.getSeconds();
+    }
+    return next;
+  }
+  const span = max - min + 1;
+  const stepped = ((current - min + delta) % span + span) % span + min;
+  if (field === "hour") {
+    next.hour = stepped;
+  } else if (field === "minute") {
+    next.minute = stepped;
+  } else {
+    next.second = stepped;
+  }
+  return next;
+}
+function typeTimeDigit(field, buffer, digit, hour12) {
+  if (!/^[0-9]$/.test(digit)) {
+    return { value: bufferToValue(buffer), buffer, advance: false };
+  }
+  if (field === "dayPeriod") {
+    return { value: bufferToValue(buffer), buffer, advance: false };
+  }
+  if (field === "hour") {
+    if (hour12) {
+      return typeNumericSegment(buffer, digit, 1, 12);
+    }
+    return typeNumericSegment(buffer, digit, 0, 23);
+  }
+  return typeNumericSegment(buffer, digit, 0, 59);
+}
+function typeNumericSegment(buffer, digit, min, max) {
+  const d = Number(digit);
+  if (buffer === "") {
+    if (d === 0 && min === 0) {
+      return { value: 0, buffer: "0", advance: false };
+    }
+    if (d === 0) {
+      return { value: null, buffer: "0", advance: false };
+    }
+    if (d * 10 > max) {
+      return { value: clamp(d, min, max), buffer: "", advance: true };
+    }
+    return { value: d, buffer: digit, advance: false };
+  }
+  const combined = Number(buffer + digit);
+  if (combined >= min && combined <= max) {
+    return { value: combined, buffer: "", advance: true };
+  }
+  if (buffer === "0" && d === 0) {
+    return { value: min === 0 ? 0 : null, buffer: "0", advance: false };
+  }
+  return typeNumericSegment("", digit, min, max);
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function bufferToValue(buffer) {
+  if (!buffer) {
+    return null;
+  }
+  const n = Number(buffer);
+  return Number.isFinite(n) ? n : null;
+}
+function dayPeriodFromKey(key) {
+  if (key === "a" || key === "A") {
+    return 0;
+  }
+  if (key === "p" || key === "P") {
+    return 1;
+  }
+  return null;
+}
+function formatTimeSegmentText(field, value, buffer, placeholder, locale) {
+  if (field === "dayPeriod") {
+    if (value == null) {
+      return placeholder;
+    }
+    return formatDayPeriod(locale, value);
+  }
+  if (buffer) {
+    return buffer.padStart(2, "0");
+  }
+  if (value == null) {
+    return placeholder;
+  }
+  return String(value).padStart(2, "0");
+}
+function isTimeComplete(segments, opts) {
+  if (segments.hour == null || segments.minute == null) {
+    return false;
+  }
+  if (opts.withSeconds && segments.second == null) {
+    return false;
+  }
+  if (opts.hour12 && segments.dayPeriod == null) {
+    return false;
+  }
+  return true;
+}
+function isTimeEmpty(segments) {
+  return segments.hour == null && segments.minute == null && segments.second == null && segments.dayPeriod == null;
+}
+function timeSegmentsToWire(segments, opts) {
+  if (!isTimeComplete(segments, opts)) {
+    return "";
+  }
+  let h24 = segments.hour;
+  if (opts.hour12) {
+    const period = segments.dayPeriod;
+    h24 = h24 === 12 ? period === 0 ? 0 : 12 : period === 1 ? h24 + 12 : h24;
+  }
+  if (h24 < 0 || h24 > 23) {
+    return "";
+  }
+  const min = segments.minute;
+  if (min < 0 || min > 59) {
+    return "";
+  }
+  const hh = String(h24).padStart(2, "0");
+  const mm = String(min).padStart(2, "0");
+  if (!opts.withSeconds) {
+    return `${hh}:${mm}`;
+  }
+  const sec = segments.second;
+  if (sec < 0 || sec > 59) {
+    return "";
+  }
+  const ss = String(sec).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function wireToTimeSegments(wire, opts) {
+  const empty = { hour: null, minute: null, second: null, dayPeriod: null };
+  if (!wire) {
+    return empty;
+  }
+  const match = /^(\d{1,2}):(\d{2})(?::(\d{2}(?:\.\d+)?))?$/.exec(wire);
+  if (!match) {
+    return empty;
+  }
+  const h24 = Number(match[1]);
+  const min = Number(match[2]);
+  const sec = match[3] != null ? Math.trunc(Number(match[3])) : null;
+  if (!Number.isFinite(h24) || !Number.isFinite(min)) {
+    return empty;
+  }
+  if (h24 < 0 || h24 > 23 || min < 0 || min > 59) {
+    return empty;
+  }
+  if (sec != null && (sec < 0 || sec > 59)) {
+    return empty;
+  }
+  let displayHour;
+  let dayPeriod = null;
+  if (opts.hour12) {
+    dayPeriod = h24 >= 12 ? 1 : 0;
+    displayHour = h24 % 12 || 12;
+  } else {
+    displayHour = h24;
+  }
+  return {
+    hour: displayHour,
+    minute: min,
+    second: opts.withSeconds ? sec ?? 0 : null,
+    dayPeriod: opts.hour12 ? dayPeriod : null
+  };
+}
+function withSecondsForStep(step) {
+  if (step === "any") {
+    return true;
+  }
+  if (!Number.isFinite(step) || step <= 0) {
+    return false;
+  }
+  return step < 60 || step % 60 !== 0;
+}
+function timeSegmentRules(opts) {
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    typeDigit: (group, field, buffer, digit) => {
+      const result = typeTimeDigit(field, buffer, digit, opts.hour12());
+      const segments = opts.getSegments(group);
+      const next = { ...segments, [field]: result.value };
+      opts.setSegments(group, next);
+      return result;
+    },
+    step: (group, field, delta) => {
+      const next = stepTimeSegment(opts.getSegments(group), field, delta, opts.hour12(), now());
+      opts.setSegments(group, next);
+      return { value: next[field] };
+    },
+    bounds: (_g, field) => timeSegmentBounds(field, opts.hour12()),
+    commitBuffer: (group, field, buffer) => {
+      const value = bufferToValue(buffer);
+      const segments = opts.getSegments(group);
+      opts.setSegments(group, { ...segments, [field]: value });
+      return value;
+    },
+    clear: (group, field) => {
+      const segments = opts.getSegments(group);
+      if (segments[field] == null) {
+        return false;
+      }
+      opts.setSegments(group, { ...segments, [field]: null });
+      return true;
+    }
+  };
+}
+
+export {
+  clearTimeSegmentLayoutCache,
+  buildTimeSegmentLayout,
+  resolveHour12,
+  formatDayPeriod,
+  timeSegmentBounds,
+  stepTimeSegment,
+  typeTimeDigit,
+  bufferToValue,
+  dayPeriodFromKey,
+  formatTimeSegmentText,
+  isTimeComplete,
+  isTimeEmpty,
+  timeSegmentsToWire,
+  wireToTimeSegments,
+  withSecondsForStep,
+  timeSegmentRules
+};

package/dist/unbundled/chunks/chunk.SZBZBSWR.js

@@ -0,0 +1,20 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/utilities/defined.ts
+async function allDefined(options) {
+  const opts = {
+    match: (tagName) => tagName.startsWith("cs-"),
+    additionalElements: [],
+    root: document,
+    ...options
+  };
+  const additionalElements = Array.isArray(opts.additionalElements) ? opts.additionalElements : [opts.additionalElements];
+  const undefinedElements = [...opts.root.querySelectorAll(":not(:defined)")].map((el) => el.localName).filter((tag, index, arr) => arr.indexOf(tag) === index).filter((tag) => opts.match(tag));
+  const tagsToAwait = [...undefinedElements, ...additionalElements];
+  await Promise.all(tagsToAwait.map((tag) => customElements.whenDefined(tag)));
+  await new Promise(requestAnimationFrame);
+}
+
+export {
+  allDefined
+};

package/dist/unbundled/chunks/chunk.TEXH52F4.js

@@ -0,0 +1,13 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/events/page-change.ts
+var CsPageChangeEvent = class extends Event {
+  constructor(detail) {
+    super("cs-page-change", { bubbles: true, cancelable: true, composed: true });
+    this.detail = detail;
+  }
+};
+
+export {
+  CsPageChangeEvent
+};

package/dist/unbundled/chunks/chunk.TGKALMAB.js

@@ -0,0 +1,81 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  progress_bar_styles_default
+} from "./chunk.JE2UA4CR.js";
+import {
+  clamp
+} from "./chunk.3TYQE67G.js";
+import {
+  CornerstoneElement,
+  customElement
+} from "./chunk.UQMDB327.js";
+import {
+  LocalizeController
+} from "./chunk.V3OJKPQZ.js";
+import {
+  __decorateClass
+} from "./chunk.LOD6ZXF2.js";
+
+// src/components/progress-bar/progress-bar.ts
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+var CsProgressBar = class extends CornerstoneElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+    this.value = 0;
+    this.indeterminate = false;
+    this.label = "";
+  }
+  willUpdate(changedProperties) {
+    if (this.style == null) {
+      this.setStyleProperty("--percentage", `${clamp(this.value, 0, 100)}%`);
+    }
+    super.willUpdate(changedProperties);
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("value")) {
+      requestAnimationFrame(() => {
+        this.style.setProperty("--percentage", `${clamp(this.value, 0, 100)}%`);
+      });
+    }
+    super.updated(changedProperties);
+  }
+  render() {
+    return html`
+      <div
+        part="progress-bar"
+        class="progress-bar"
+        role="progressbar"
+        title=${ifDefined(this.title)}
+        aria-label=${this.label.length > 0 ? this.label : this.localize.term("progress")}
+        aria-describedby="label"
+        aria-valuemin="0"
+        aria-valuemax="100"
+        aria-valuenow=${this.indeterminate ? "0" : this.value}
+      >
+        <div part="indicator" class="indicator">
+          ${!this.indeterminate ? html` <slot id="label" part="label" class="label"></slot> ` : ""}
+        </div>
+      </div>
+    `;
+  }
+};
+CsProgressBar.css = progress_bar_styles_default;
+__decorateClass([
+  property({ type: Number, reflect: true })
+], CsProgressBar.prototype, "value", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], CsProgressBar.prototype, "indeterminate", 2);
+__decorateClass([
+  property()
+], CsProgressBar.prototype, "label", 2);
+CsProgressBar = __decorateClass([
+  customElement("cs-progress-bar")
+], CsProgressBar);
+
+export {
+  CsProgressBar
+};

package/dist/unbundled/chunks/chunk.TJPDMYIO.js

@@ -0,0 +1,61 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/components/carousel/autoplay-controller.ts
+var AutoplayController = class {
+  constructor(host, tickCallback) {
+    this.timerId = 0;
+    this.activeInteractions = 0;
+    this.paused = false;
+    this.stopped = true;
+    this.pause = () => {
+      if (!this.activeInteractions++) {
+        this.paused = true;
+        this.host.requestUpdate();
+      }
+    };
+    this.resume = () => {
+      if (!--this.activeInteractions) {
+        this.paused = false;
+        this.host.requestUpdate();
+      }
+    };
+    host.addController(this);
+    this.host = host;
+    this.tickCallback = tickCallback;
+  }
+  hostConnected() {
+    this.host.addEventListener("mouseenter", this.pause);
+    this.host.addEventListener("mouseleave", this.resume);
+    this.host.addEventListener("focusin", this.pause);
+    this.host.addEventListener("focusout", this.resume);
+    this.host.addEventListener("touchstart", this.pause, { passive: true });
+    this.host.addEventListener("touchend", this.resume);
+  }
+  hostDisconnected() {
+    this.stop();
+    this.host.removeEventListener("mouseenter", this.pause);
+    this.host.removeEventListener("mouseleave", this.resume);
+    this.host.removeEventListener("focusin", this.pause);
+    this.host.removeEventListener("focusout", this.resume);
+    this.host.removeEventListener("touchstart", this.pause);
+    this.host.removeEventListener("touchend", this.resume);
+  }
+  start(interval) {
+    this.stop();
+    this.stopped = false;
+    this.timerId = window.setInterval(() => {
+      if (!this.paused) {
+        this.tickCallback();
+      }
+    }, interval);
+  }
+  stop() {
+    clearInterval(this.timerId);
+    this.stopped = true;
+    this.host.requestUpdate();
+  }
+};
+
+export {
+  AutoplayController
+};

package/dist/unbundled/chunks/chunk.TMFCJJXQ.js

@@ -0,0 +1,47 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/internal/live-announcer.ts
+var politeLog = null;
+var assertiveLog = null;
+var CLEAR_DELAY = 7e3;
+function createLog(politeness) {
+  const log = document.createElement("div");
+  log.setAttribute("role", "log");
+  log.setAttribute("aria-live", politeness);
+  log.setAttribute("aria-relevant", "additions");
+  Object.assign(log.style, {
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    margin: "-1px",
+    padding: "0",
+    border: "0",
+    overflow: "hidden",
+    clip: "rect(0 0 0 0)",
+    clipPath: "inset(50%)",
+    whiteSpace: "nowrap"
+  });
+  return log;
+}
+function getLog(politeness) {
+  if (politeness === "assertive") {
+    assertiveLog ?? (assertiveLog = document.body.appendChild(createLog("assertive")));
+    return assertiveLog;
+  }
+  politeLog ?? (politeLog = document.body.appendChild(createLog("polite")));
+  return politeLog;
+}
+function announce(message, politeness = "polite") {
+  if (!message) {
+    return;
+  }
+  const log = getLog(politeness);
+  const node = document.createElement("div");
+  node.textContent = message;
+  log.appendChild(node);
+  setTimeout(() => node.remove(), CLEAR_DELAY);
+}
+
+export {
+  announce
+};

package/dist/unbundled/chunks/chunk.TNVOKJ6N.js

@@ -0,0 +1,114 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  CornerstoneElement,
+  customElement
+} from "./chunk.UQMDB327.js";
+import {
+  LocalizeController
+} from "./chunk.V3OJKPQZ.js";
+import {
+  __decorateClass
+} from "./chunk.LOD6ZXF2.js";
+
+// src/components/relative-time/relative-time.ts
+import { html } from "lit";
+import { property, state } from "lit/decorators.js";
+var availableUnits = [
+  { max: 276e4, value: 6e4, unit: "minute" },
+  // max 46 minutes
+  { max: 72e6, value: 36e5, unit: "hour" },
+  // max 20 hours
+  { max: 5184e5, value: 864e5, unit: "day" },
+  // max 6 days
+  { max: 24192e5, value: 6048e5, unit: "week" },
+  // max 28 days
+  { max: 28512e6, value: 2592e6, unit: "month" },
+  // max 11 months
+  { max: Infinity, value: 31536e6, unit: "year" }
+];
+var CsRelativeTime = class extends CornerstoneElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+    this.isoTime = "";
+    this.relativeTime = "";
+    this.date = /* @__PURE__ */ new Date();
+    this.format = "long";
+    this.numeric = "auto";
+    this.sync = false;
+    this.referenceDate = null;
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    clearTimeout(this.updateTimeout);
+  }
+  willUpdate(changedProperties) {
+    const now = this.referenceDate || /* @__PURE__ */ new Date();
+    const then = new Date(this.date);
+    if (isNaN(then.getMilliseconds())) {
+      this.relativeTime = "";
+      this.isoTime = "";
+      return super.willUpdate(changedProperties);
+    }
+    const diff = then.getTime() - now.getTime();
+    const { unit, value } = availableUnits.find((singleUnit) => Math.abs(diff) < singleUnit.max);
+    this.isoTime = then.toISOString();
+    this.relativeTime = this.localize.relativeTime(Math.round(diff / value), unit, {
+      numeric: this.numeric,
+      style: this.format
+    });
+    clearTimeout(this.updateTimeout);
+    if (this.sync) {
+      let nextInterval;
+      if (unit === "minute") {
+        nextInterval = getTimeUntilNextUnit("second");
+      } else if (unit === "hour") {
+        nextInterval = getTimeUntilNextUnit("minute");
+      } else if (unit === "day") {
+        nextInterval = getTimeUntilNextUnit("hour");
+      } else {
+        nextInterval = getTimeUntilNextUnit("day");
+      }
+      this.updateTimeout = setTimeout(() => this.requestUpdate(), nextInterval);
+    }
+  }
+  render() {
+    if (this.relativeTime === "" && this.isoTime === "") {
+      return "";
+    }
+    return html`<time datetime=${this.isoTime}>${this.relativeTime}</time>`;
+  }
+};
+__decorateClass([
+  state()
+], CsRelativeTime.prototype, "isoTime", 2);
+__decorateClass([
+  state()
+], CsRelativeTime.prototype, "relativeTime", 2);
+__decorateClass([
+  property()
+], CsRelativeTime.prototype, "date", 2);
+__decorateClass([
+  property()
+], CsRelativeTime.prototype, "format", 2);
+__decorateClass([
+  property()
+], CsRelativeTime.prototype, "numeric", 2);
+__decorateClass([
+  property({ type: Boolean })
+], CsRelativeTime.prototype, "sync", 2);
+__decorateClass([
+  state()
+], CsRelativeTime.prototype, "referenceDate", 2);
+CsRelativeTime = __decorateClass([
+  customElement("cs-relative-time")
+], CsRelativeTime);
+function getTimeUntilNextUnit(unit) {
+  const units = { second: 1e3, minute: 6e4, hour: 36e5, day: 864e5 };
+  const value = units[unit];
+  return value - Date.now() % value;
+}
+
+export {
+  CsRelativeTime
+};

package/dist/unbundled/chunks/chunk.TPTOM4IN.js

@@ -0,0 +1,24 @@
+/*! Cornerstone Components 0.6.1 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  CsIntersectionObserver
+} from "./chunk.HYKSQJB5.js";
+
+// src/react/intersection-observer/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "cs-intersection-observer";
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: CsIntersectionObserver,
+  react: React,
+  events: {
+    onCsIntersect: "cs-intersect"
+  },
+  displayName: "CsIntersectionObserver"
+});
+var intersection_observer_default = reactWrapper;
+
+export {
+  intersection_observer_default
+};