@scalar/helpers 0.4.2 → 0.4.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @scalar/helpers
 
+## 0.4.3
+
+### Patch Changes
+
+- [#8692](https://github.com/scalar/scalar/pull/8692): feat: replace pretty-bytes dependency with internal helper
+- [#8555](https://github.com/scalar/scalar/pull/8555): feat: add getMarkdownHeadings utility
+
 ## 0.4.2
 
 ### Patch Changes

package/dist/dom/get-selector.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Similar to the copy selector from chrome devtools, this allows you to get a CSS selector for an element
+ *
+ * Helpful when elements are being re-created and you cannot use a ref for it
+ */
+export declare const getSelector: (el: Element | null) => string | null;
+//# sourceMappingURL=get-selector.d.ts.map

package/dist/dom/get-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-selector.d.ts","sourceRoot":"","sources":["../../src/dom/get-selector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,IAAI,OAAO,GAAG,IAAI,KAAG,MAAM,GAAG,IA8BzD,CAAA"}

package/dist/dom/get-selector.js

@@ -0,0 +1,31 @@
+/**
+ * Similar to the copy selector from chrome devtools, this allows you to get a CSS selector for an element
+ *
+ * Helpful when elements are being re-created and you cannot use a ref for it
+ */
+export const getSelector = (el) => {
+    if (!el || !(el instanceof Element)) {
+        return null;
+    }
+    const path = [];
+    let node = el;
+    while (node instanceof Element) {
+        const tag = node.localName;
+        /**
+         * Count same-tag preceding siblings to determine nth-of-type index.
+         * Walking backwards is cheaper than counting all siblings and finding our
+         * position from the front, since we stop as soon as we reach the start.
+         */
+        let nth = 1;
+        let sibling = node.previousElementSibling;
+        while (sibling) {
+            if (sibling.localName === tag) {
+                nth++;
+            }
+            sibling = sibling.previousElementSibling;
+        }
+        path.unshift(nth > 1 ? `${tag}:nth-of-type(${nth})` : tag);
+        node = node.parentElement;
+    }
+    return path.join(' > ');
+};

package/dist/formatters/format-bytes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Format a byte count as a human-readable decimal value
+ * @example 1024 -> 1 kB
+ * @example 1025 -> 1.03 kB
+ */
+export declare const formatBytes: (value: number, precision?: number) => string;
+//# sourceMappingURL=format-bytes.d.ts.map

package/dist/formatters/format-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-bytes.d.ts","sourceRoot":"","sources":["../../src/formatters/format-bytes.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,kBAAa,KAAG,MAc1D,CAAA"}

package/dist/formatters/format-bytes.js

@@ -0,0 +1,18 @@
+const UNITS = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+/**
+ * Format a byte count as a human-readable decimal value
+ * @example 1024 -> 1 kB
+ * @example 1025 -> 1.03 kB
+ */
+export const formatBytes = (value, precision = 3) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return '0 B';
+    }
+    // toPrecision rounding can push the value to 1000, overflowing the current unit
+    let unitIndex = Math.max(0, Math.min(Math.floor(Math.log10(value) / 3), UNITS.length - 1));
+    const normalizedValue = Number((value / 1000 ** unitIndex).toPrecision(precision));
+    if (normalizedValue >= 1000 && unitIndex < UNITS.length - 1) {
+        unitIndex += 1;
+    }
+    return `${Number((value / 1000 ** unitIndex).toPrecision(precision))} ${UNITS[unitIndex]}`;
+};

package/dist/formatters/format-milliseconds.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formats milliseconds to seconds and appends an "s" if more than one second
+ * else returns ms appended to the number
+ */
+export declare const formatMilliseconds: (ms: number, decimals?: number) => string;
+//# sourceMappingURL=format-milliseconds.d.ts.map

package/dist/formatters/format-milliseconds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-milliseconds.d.ts","sourceRoot":"","sources":["../../src/formatters/format-milliseconds.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,MAAM,EAAE,iBAAY,KAAG,MAK7D,CAAA"}

package/dist/formatters/format-milliseconds.js

@@ -0,0 +1,10 @@
+/**
+ * Formats milliseconds to seconds and appends an "s" if more than one second
+ * else returns ms appended to the number
+ */
+export const formatMilliseconds = (ms, decimals = 2) => {
+    if (ms > 1000) {
+        return (ms / 1000).toFixed(decimals) + 's';
+    }
+    return ms + 'ms';
+};

package/dist/markdown/get-markdown-headings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extract all headings from a Markdown string without any library dependencies.
+ *
+ * Correctly skips headings inside fenced code blocks (``` or ~~~) and
+ * indented code blocks (4+ spaces or tab).
+ */
+export declare function getMarkdownHeadings(markdown: string): {
+    depth: number;
+    value: string;
+}[];
+//# sourceMappingURL=get-markdown-headings.d.ts.map

package/dist/markdown/get-markdown-headings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-markdown-headings.d.ts","sourceRoot":"","sources":["../../src/markdown/get-markdown-headings.ts"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACrD,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,EAAE,CA2EF"}

package/dist/markdown/get-markdown-headings.js

@@ -0,0 +1,99 @@
+/**
+ * Strips inline Markdown formatting to extract plain text.
+ *
+ * Handles: links, images, bold/italic, inline code, strikethrough, and HTML tags.
+ */
+function stripInlineMarkdown(text) {
+    return (text
+        // Images: ![alt](url) → alt
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+        // Links: [text](url) → text
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        // Bold/italic combos: ***text*** or ___text___
+        .replace(/(\*{3}|_{3})(.+?)\1/g, '$2')
+        // Bold: **text** or __text__
+        .replace(/(\*{2}|_{2})(.+?)\1/g, '$2')
+        // Italic: *text* or _text_
+        .replace(/(\*|_)(.+?)\1/g, '$2')
+        // Strikethrough: ~~text~~
+        .replace(/~~(.+?)~~/g, '$1')
+        // Inline code: `code`
+        .replace(/`([^`]+)`/g, '$1')
+        // HTML tags
+        .replace(/<[^>]+>/g, '')
+        // Remove any remaining angle brackets to avoid partial/malformed HTML fragments
+        .replace(/[<>]/g, '')
+        .trim());
+}
+/**
+ * Extract all headings from a Markdown string without any library dependencies.
+ *
+ * Correctly skips headings inside fenced code blocks (``` or ~~~) and
+ * indented code blocks (4+ spaces or tab).
+ */
+export function getMarkdownHeadings(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const headings = [];
+    let inFencedBlock = false;
+    let fenceChar = '';
+    let fenceLength = 0;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? '';
+        const trimmed = line.trimStart();
+        if (!inFencedBlock) {
+            const fence = /^(`{3,}|~{3,})/.exec(trimmed)?.[1];
+            if (fence) {
+                inFencedBlock = true;
+                fenceChar = fence.charAt(0);
+                fenceLength = fence.length;
+                continue;
+            }
+        }
+        else {
+            const closeFence = /^(`{3,}|~{3,})\s*$/.exec(trimmed)?.[1];
+            if (closeFence && closeFence[0] === fenceChar && closeFence.length >= fenceLength) {
+                inFencedBlock = false;
+            }
+            continue;
+        }
+        // Skip indented code blocks (4 spaces or 1 tab)
+        if (/^(?: {4}|\t)/.test(line)) {
+            continue;
+        }
+        // Match ATX headings: 1-6 # characters followed by a space
+        const headingMatch = /^(#{1,6})\s+(.+?)(?:\s+#+\s*)?$/.exec(trimmed);
+        const hashes = headingMatch?.[1];
+        const rawText = headingMatch?.[2];
+        if (hashes && rawText) {
+            const value = stripInlineMarkdown(rawText);
+            if (value) {
+                headings.push({
+                    depth: hashes.length,
+                    value,
+                });
+            }
+            continue;
+        }
+        // Match setext headings:
+        // Heading level 1: Text followed by ===
+        // Heading level 2: Text followed by ---
+        const nextLine = lines[index + 1];
+        if (!nextLine || /^(?: {4}|\t)/.test(nextLine)) {
+            continue;
+        }
+        const underline = /^(=+|-+)\s*$/.exec(nextLine.trim())?.[1];
+        if (!underline) {
+            continue;
+        }
+        const value = stripInlineMarkdown(trimmed);
+        if (!value) {
+            continue;
+        }
+        headings.push({
+            depth: underline[0] === '=' ? 1 : 2,
+            value,
+        });
+        index++;
+    }
+    return headings;
+}

package/package.json

@@ -14,7 +14,7 @@
     "helpers",
     "js"
   ],
-  "version": "0.4.2",
+  "version": "0.4.3",
   "engines": {
     "node": ">=22"
   },
@@ -47,6 +47,11 @@
       "types": "./dist/file/*.d.ts",
       "default": "./dist/file/*.js"
     },
+    "./formatters/*": {
+      "import": "./dist/formatters/*.js",
+      "types": "./dist/formatters/*.d.ts",
+      "default": "./dist/formatters/*.js"
+    },
     "./general/*": {
       "import": "./dist/general/*.js",
       "types": "./dist/general/*.d.ts",
@@ -62,6 +67,11 @@
       "types": "./dist/json/*.d.ts",
       "default": "./dist/json/*.js"
     },
+    "./markdown/*": {
+      "import": "./dist/markdown/*.js",
+      "types": "./dist/markdown/*.d.ts",
+      "default": "./dist/markdown/*.js"
+    },
     "./node/*": {
       "import": "./dist/node/*.js",
       "types": "./dist/node/*.d.ts",
@@ -97,9 +107,9 @@
     "dist",
     "CHANGELOG.md"
   ],
+  "sideEffects": false,
   "devDependencies": {
     "jsdom": "27.4.0",
-    "vite": "8.0.0",
     "vitest": "4.1.0"
   },
   "scripts": {