@birdapi/velinstyle 1.0.0 → 1.1.0

package/dist/chunks/chunk-QVHYL3R4.js

@@ -0,0 +1,111 @@
+// components/runtime/component-loaders.js
+var COMPONENT_LOADERS = {
+  "velin-accordion": () => import("./velin-accordion-QAQO7BI7.js"),
+  "velin-announcer": () => import("./velin-announcer-PVTXXCWR.js"),
+  "velin-bottom-nav": () => import("./velin-bottom-nav-CTU6FFZV.js"),
+  "velin-carousel": () => import("./velin-carousel-ZTBANFQQ.js"),
+  "velin-code-block": () => import("./velin-code-block-ITCLIC6T.js"),
+  "velin-collapse": () => import("./velin-collapse-5XYBUIID.js"),
+  "velin-combobox": () => import("./velin-combobox-UGA56HP3.js"),
+  "velin-command": () => import("./velin-command-CKDNO4BW.js"),
+  "velin-copy": () => import("./velin-copy-G2TZ5YBB.js"),
+  "velin-countdown": () => import("./velin-countdown-7AIY66CU.js"),
+  "velin-counter": () => import("./velin-counter-L5FYJF7A.js"),
+  "velin-data-table": () => import("./velin-data-table-KK7IDGTP.js"),
+  "velin-dialog": () => import("./velin-dialog-ELFOZIXZ.js"),
+  "velin-drawer": () => import("./velin-drawer-BE6TYN3H.js"),
+  "velin-dropdown": () => import("./velin-dropdown-PLUIFA5M.js"),
+  "velin-email": () => import("./velin-email-NTM6DG3V.js"),
+  "velin-form-summary": () => import("./velin-form-summary-XRQ7COQH.js"),
+  "velin-icon": () => import("./velin-icon-WTFPG2DD.js"),
+  "velin-lightbox": () => import("./velin-lightbox-NXA3U2FM.js"),
+  "velin-live-dot": () => import("./velin-live-dot-RJHX2DGY.js"),
+  "velin-menubar": () => import("./velin-menubar-I426AED2.js"),
+  "velin-modal": () => import("./velin-modal-AEOTZ67O.js"),
+  "velin-persist": () => import("./velin-persist-DFPL3QP4.js"),
+  "velin-popover": () => import("./velin-popover-HQW6Q2Y6.js"),
+  "velin-progress-ring": () => import("./velin-progress-ring-E4YRLZHH.js"),
+  "velin-rating": () => import("./velin-rating-6CDBI6DG.js"),
+  "velin-scroll-top": () => import("./velin-scroll-top-OHYVVHHY.js"),
+  "velin-scrollspy": () => import("./velin-scrollspy-OKCT4FDV.js"),
+  "velin-search": () => import("./velin-search-FDHEMCSO.js"),
+  "velin-secure-field": () => import("./velin-secure-field-OFNAXCDP.js"),
+  "velin-segmented-control": () => import("./velin-segmented-control-EKL4E3BL.js"),
+  "velin-sheet": () => import("./velin-sheet-R2Y67X6H.js"),
+  "velin-sparkline": () => import("./velin-sparkline-XVTFC6GE.js"),
+  "velin-stepper": () => import("./velin-stepper-7ECRUYHD.js"),
+  "velin-stepper-wc": () => import("./velin-stepper-7ECRUYHD.js"),
+  "velin-tabs": () => import("./velin-tabs-5UQ5ZVMV.js"),
+  "velin-theme-toggle": () => import("./velin-theme-toggle-32J2CBNC.js"),
+  "velin-toast": () => import("./velin-toast-RSF2IHT3.js"),
+  "velin-tooltip": () => import("./velin-tooltip-HVUOKNVX.js"),
+  "velin-tooltip-wc": () => import("./velin-tooltip-HVUOKNVX.js")
+};
+
+// components/runtime/index.js
+var registry = /* @__PURE__ */ new Map();
+var VELIN_TAG_RE = /^velin-[a-z0-9-]+$/;
+function whenDefined(tagName) {
+  if (typeof customElements === "undefined") {
+    return Promise.reject(new Error("customElements not available"));
+  }
+  return customElements.whenDefined(tagName);
+}
+async function lazyDefine(tagName) {
+  const loader = COMPONENT_LOADERS[tagName];
+  if (!loader) {
+    throw new Error(`Unknown Velin component: ${tagName}`);
+  }
+  if (registry.has(tagName)) return registry.get(tagName);
+  const p = loader().then((mod) => {
+    const Cls = mod.default;
+    if (Cls && !customElements.get(tagName)) {
+      customElements.define(tagName, Cls);
+    }
+    return Cls;
+  });
+  registry.set(tagName, p);
+  return p;
+}
+async function register(tagNames) {
+  return Promise.all(tagNames.map((t) => lazyDefine(t)));
+}
+function collectTagsFromDOM(root) {
+  const tags = /* @__PURE__ */ new Set();
+  root.querySelectorAll("[data-velin-component]").forEach((el) => {
+    const name = el.getAttribute("data-velin-component");
+    if (name) tags.add(name.startsWith("velin-") ? name : `velin-${name}`);
+  });
+  for (const el of root.querySelectorAll("*")) {
+    const tag = el.tagName?.toLowerCase();
+    if (tag && VELIN_TAG_RE.test(tag) && COMPONENT_LOADERS[tag]) {
+      tags.add(tag);
+    }
+  }
+  return tags;
+}
+async function bootFromDOM(root = document, options = {}) {
+  const tags = options.tags?.length ? new Set(options.tags) : collectTagsFromDOM(root);
+  const wcPromise = register([...tags]);
+  if (options.attributes) {
+    const { bootAttributes } = await import("./attributes-353XDOAX.js");
+    await bootAttributes(root);
+  }
+  if (options.highlight) {
+    const { initHighlight } = await import("./highlight-IBDX4XWS.js");
+    initHighlight(root);
+  }
+  if (options.haptic) {
+    const { VelinHapticObserver } = await import("./velin-haptic-4QQTM3RK.js");
+    new VelinHapticObserver().start(root instanceof Document ? root.body : root);
+  }
+  return wcPromise;
+}
+
+export {
+  COMPONENT_LOADERS,
+  whenDefined,
+  lazyDefine,
+  register,
+  bootFromDOM
+};

package/dist/chunks/go-HZ6XTFCK.js

@@ -0,0 +1,31 @@
+import {
+  tokenize
+} from "./chunk-7FFAMRFV.js";
+
+// core/highlight/languages/go.js
+var RULES = [
+  { type: "comment", re: /\/\/[^\n]*/y },
+  { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+  // Raw strings may span lines.
+  { type: "string", re: /`[^`]*`/y },
+  { type: "string", re: /"(?:\\.|[^"\\\n])*"/y },
+  { type: "string", re: /'(?:\\.|[^'\\\n])*'/y },
+  { type: "number", re: /\b0[xX][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]*)?(?:[eE][+-]?\d+)?i?\b/y },
+  {
+    type: "keyword",
+    re: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go|goto|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/y
+  },
+  {
+    type: "builtin",
+    re: /\b(?:append|bool|byte|cap|clear|close|complex|complex64|complex128|copy|delete|error|float32|float64|imag|int|int8|int16|int32|int64|len|make|max|min|new|nil|panic|print|println|real|recover|rune|string|true|false|iota|uint|uint8|uint16|uint32|uint64|uintptr|any)\b/y
+  },
+  { type: "operator", re: /:=|\.\.\.|&&|\|\||<-|\+\+|--|<<=?|>>=?|&\^=?|[-+*/%&|^<>!=]=?|~/y },
+  { type: "punctuation", re: /[[\]{}(),;:.]/y },
+  { type: "identifier", re: /\b[A-Za-z_]\w*\b/y }
+];
+function lexGo(code) {
+  return tokenize(code, RULES);
+}
+export {
+  lexGo as default
+};

package/dist/chunks/highlight-IBDX4XWS.js

@@ -0,0 +1,37 @@
+import {
+  applyHighlight,
+  escapeHtml,
+  getLanguage,
+  getSourceText,
+  highlightAll,
+  highlightElement,
+  initHighlight,
+  lazyLoadLanguage,
+  listLanguages,
+  normalizeLanguage,
+  observeCodeBlocks,
+  registerLanguage,
+  renderTokens,
+  resolveLanguage,
+  velinSyntax
+} from "./chunk-ERF5YVP4.js";
+import "./chunk-7MCGPHVC.js";
+import "./chunk-M5CHQVP6.js";
+import "./chunk-7FFAMRFV.js";
+export {
+  applyHighlight,
+  escapeHtml,
+  getLanguage,
+  getSourceText,
+  highlightAll,
+  highlightElement,
+  initHighlight,
+  lazyLoadLanguage,
+  listLanguages,
+  normalizeLanguage,
+  observeCodeBlocks,
+  registerLanguage,
+  renderTokens,
+  resolveLanguage,
+  velinSyntax
+};

package/dist/chunks/python-BMPKDKNO.js

@@ -0,0 +1,32 @@
+import {
+  tokenize
+} from "./chunk-7FFAMRFV.js";
+
+// core/highlight/languages/python.js
+var RULES = [
+  { type: "comment", re: /#[^\n]*/y },
+  // Triple-quoted strings first so the single-quote rules cannot split them.
+  { type: "string", re: /[rbfu]{0,2}"""[\s\S]*?"""/y },
+  { type: "string", re: /[rbfu]{0,2}'''[\s\S]*?'''/y },
+  { type: "string", re: /[rbfu]{0,2}"(?:\\.|[^"\\\n])*"/y },
+  { type: "string", re: /[rbfu]{0,2}'(?:\\.|[^'\\\n])*'/y },
+  { type: "number", re: /\b0[xX][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?j?\b/y },
+  {
+    type: "keyword",
+    re: /\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b/y
+  },
+  {
+    type: "builtin",
+    re: /\b(?:None|True|False|self|cls|abs|all|any|bool|bytes|dict|dir|enumerate|filter|float|format|frozenset|getattr|hasattr|int|isinstance|issubclass|iter|len|list|map|max|min|next|object|open|print|range|repr|reversed|round|set|setattr|sorted|str|sum|super|tuple|type|zip)\b/y
+  },
+  // Multi-character operators first so `->` is not split into `-` and `>`.
+  { type: "operator", re: /->|:=|\*\*=?|\/\/=?|<<=?|>>=?|[-+*/%&|^~<>!=]=?/y },
+  { type: "punctuation", re: /[[\]{}(),:;.@]/y },
+  { type: "identifier", re: /\b[A-Za-z_]\w*\b/y }
+];
+function lexPython(code) {
+  return tokenize(code, RULES);
+}
+export {
+  lexPython as default
+};

package/dist/chunks/runtime-entry.js

@@ -4,7 +4,7 @@ import {
   lazyDefine,
   register,
   whenDefined
-} from "./chunk-IEHKRARD.js";
+} from "./chunk-QVHYL3R4.js";
 export {
   COMPONENT_LOADERS,
   bootFromDOM,

package/dist/chunks/rust-2BWKI2MN.js

@@ -0,0 +1,35 @@
+import {
+  tokenize
+} from "./chunk-7FFAMRFV.js";
+
+// core/highlight/languages/rust.js
+var RULES = [
+  { type: "comment", re: /\/\/\/?[^\n]*/y },
+  { type: "comment", re: /\/\*[\s\S]*?\*\//y },
+  // Raw strings close on the same number of hashes they opened with.
+  { type: "string", re: /b?r(#*)"[\s\S]*?"\1/y },
+  { type: "string", re: /b?"(?:\\.|[^"\\])*"/y },
+  { type: "string", re: /b?'(?:\\.|[^'\\])'/y },
+  // Attributes such as #[derive(Debug)] read as annotations.
+  { type: "builtin", re: /#!?\[[^\]]*\]/y },
+  { type: "number", re: /\b0[xXbo][\da-fA-F_]+\b|\b\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?(?:[iuf](?:8|16|32|64|128|size))?\b/y },
+  {
+    type: "keyword",
+    re: /\b(?:as|async|await|break|const|continue|crate|dyn|else|enum|extern|fn|for|if|impl|in|let|loop|match|mod|move|mut|pub|ref|return|self|Self|static|struct|super|trait|type|unsafe|use|where|while)\b/y
+  },
+  {
+    type: "builtin",
+    re: /\b(?:bool|char|f32|f64|i8|i16|i32|i64|i128|isize|str|u8|u16|u32|u64|u128|usize|String|Vec|Option|Result|Some|None|Ok|Err|Box|Rc|Arc|true|false)\b/y
+  },
+  // Lifetimes such as 'a must not be read as an unterminated char literal.
+  { type: "operator", re: /'[a-z_]\w*\b/y },
+  { type: "operator", re: /=>|->|::|\.\.=?|&&|\|\||<<=?|>>=?|[-+*/%&|^<>!=]=?|[?@]/y },
+  { type: "punctuation", re: /[[\]{}(),;:.#]/y },
+  { type: "identifier", re: /\b[A-Za-z_]\w*!?\b/y }
+];
+function lexRust(code) {
+  return tokenize(code, RULES);
+}
+export {
+  lexRust as default
+};

package/dist/chunks/velin-code-block-ITCLIC6T.js

@@ -0,0 +1,132 @@
+import {
+  highlightElement,
+  initHighlight
+} from "./chunk-ERF5YVP4.js";
+import "./chunk-7MCGPHVC.js";
+import "./chunk-M5CHQVP6.js";
+import "./chunk-7FFAMRFV.js";
+
+// components/velin-code-block.js
+function parseLineHighlight(spec) {
+  const lines = /* @__PURE__ */ new Set();
+  if (!spec) return lines;
+  for (const part of spec.split(",")) {
+    const p = part.trim();
+    if (!p) continue;
+    if (p.includes("-")) {
+      const [a, b] = p.split("-").map((n) => parseInt(n, 10));
+      if (!Number.isNaN(a) && !Number.isNaN(b)) {
+        for (let i = Math.min(a, b); i <= Math.max(a, b); i += 1) lines.add(i);
+      }
+    } else {
+      const n = parseInt(p, 10);
+      if (!Number.isNaN(n)) lines.add(n);
+    }
+  }
+  return lines;
+}
+var VelinCodeBlock = class extends HTMLElement {
+  static get observedAttributes() {
+    return ["language", "highlight", "line-numbers", "collapsed"];
+  }
+  connectedCallback() {
+    if (this._built) return;
+    this._built = true;
+    this.classList.add("velin-code-block");
+    this._render();
+    this._setupHighlight();
+  }
+  attributeChangedCallback() {
+    if (!this._built) return;
+    this._render();
+    this._setupHighlight();
+  }
+  _render() {
+    const lang = this.getAttribute("language") || "";
+    const showLines = this.hasAttribute("line-numbers");
+    const collapsed = this.hasAttribute("collapsed");
+    const highlightLines = parseLineHighlight(this.getAttribute("highlight") || "");
+    const source = this.textContent.trim();
+    this.textContent = "";
+    const toolbar = document.createElement("div");
+    toolbar.className = "velin-code-block__toolbar";
+    toolbar.innerHTML = "";
+    const copyWc = document.createElement("velin-copy");
+    copyWc.setAttribute("value", source);
+    copyWc.setAttribute("label", "Copy");
+    toolbar.appendChild(copyWc);
+    const panelId = `velin-code-panel-${Math.random().toString(36).slice(2, 9)}`;
+    const wrap = document.createElement("div");
+    wrap.id = panelId;
+    wrap.className = showLines ? "velin-code-block__gutter" : "";
+    if (collapsed) {
+      const toggle = document.createElement("button");
+      toggle.type = "button";
+      toggle.className = "velin-btn velin-btn--sm velin-btn--ghost";
+      toggle.textContent = "Expand";
+      toggle.setAttribute("aria-expanded", "false");
+      toggle.setAttribute("aria-controls", panelId);
+      toggle.setAttribute("aria-label", "Expand code block");
+      toggle.addEventListener("click", () => {
+        const on = this.hasAttribute("data-collapsed");
+        if (on) {
+          this.removeAttribute("data-collapsed");
+          toggle.textContent = "Collapse";
+          toggle.setAttribute("aria-expanded", "true");
+          toggle.setAttribute("aria-label", "Collapse code block");
+        } else {
+          this.setAttribute("data-collapsed", "");
+          toggle.textContent = "Expand";
+          toggle.setAttribute("aria-expanded", "false");
+          toggle.setAttribute("aria-label", "Expand code block");
+        }
+      });
+      this.setAttribute("data-collapsed", "");
+      toolbar.appendChild(toggle);
+    }
+    if (showLines) {
+      const gutter = document.createElement("div");
+      gutter.className = "velin-code-block__line-numbers";
+      const lines = source.split("\n");
+      const lineCount = lines.length;
+      gutter.textContent = "";
+      for (let i = 0; i < lineCount; i += 1) {
+        const n = i + 1;
+        const span = document.createElement("span");
+        if (highlightLines.has(n)) span.className = "velin-code-block__line--highlight";
+        span.textContent = String(n);
+        gutter.appendChild(span);
+      }
+      wrap.appendChild(gutter);
+    }
+    const pre = document.createElement("pre");
+    if (lang) {
+      pre.setAttribute("language", lang);
+      pre.dataset.language = lang;
+    }
+    const code = document.createElement("code");
+    if (lang) code.className = `language-${lang}`;
+    code.textContent = source;
+    pre.appendChild(code);
+    wrap.appendChild(pre);
+    this.appendChild(toolbar);
+    this.appendChild(wrap);
+    this._pre = pre;
+  }
+  async _setupHighlight() {
+    if (!this._pre) return;
+    delete this._pre.dataset.velinHighlighted;
+    delete this._pre.dataset.velinObserve;
+    const immediate = typeof matchMedia !== "undefined" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (immediate) {
+      await highlightElement(this._pre);
+    } else {
+      initHighlight(this, { root: this });
+    }
+  }
+};
+customElements.define("velin-code-block", VelinCodeBlock);
+var velin_code_block_default = VelinCodeBlock;
+export {
+  velin_code_block_default as default
+};