@stats-forge/github-stats-forge-core 0.0.2 → 0.2.0

package/build/markup/css.d.ts

@@ -0,0 +1,35 @@
+import type { Sink } from './serialize.ts';
+/** Every CSS property a card declares, closed so a typo is a compile error, not a dropped rule. */
+type CssProperty = '-webkit-box-orient' | '-webkit-line-clamp' | 'animation' | 'animation-delay' | 'animation-duration' | 'color' | 'display' | 'fill' | 'font' | 'font-size' | 'font-variant-numeric' | 'font-weight' | 'line-clamp' | 'line-height' | 'margin' | 'opacity' | 'overflow' | 'overflow-wrap' | 'padding-bottom' | 'stroke' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-linecap' | 'stroke-width' | 'text-overflow' | 'transform' | 'transform-origin' | 'width' | 'word-break';
+/** A declaration whose value is `undefined` is left out, so a caller can inline a condition. */
+type Declarations = Partial<Record<CssProperty, string | number | undefined>>;
+type CssNode = {
+    readonly kind: 'rule';
+    readonly selector: string;
+    readonly declarations: Declarations;
+} | {
+    readonly kind: 'at';
+    readonly prelude: string;
+    readonly children: Array<CssChild>;
+} | {
+    readonly kind: 'comment';
+    readonly text: string;
+};
+/** Anything accepted where CSS is expected; falsy entries drop out, arrays flatten. */
+type CssChild = CssNode | false | null | undefined | Array<CssChild>;
+/**
+ * Selectors stay free-form: they compose (`.badge rect`), and a keyframe stop is one too (`from`).
+ */
+declare const rule: (selector: string, declarations: Declarations) => CssNode;
+declare const atRule: (prelude: string, ...children: Array<CssChild>) => CssNode;
+declare const cssComment: (text: string) => CssNode;
+/**
+ * Serializes a stylesheet, dropping every rule that would have come out empty.
+ *
+ * A block is written optimistically and rewound if its body turns out empty,
+ * so the tree is walked once however deeply the at-rules nest.
+ */
+declare const writeCss: (children: Array<CssChild>, depth: number, sink: Sink) => void;
+export { atRule, cssComment, rule, writeCss };
+export type { CssChild, Declarations };
+//# sourceMappingURL=css.d.ts.map

package/build/markup/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/markup/css.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG3C,mGAAmG;AACnG,KAAK,WAAW,GACZ,oBAAoB,GACpB,oBAAoB,GACpB,WAAW,GACX,iBAAiB,GACjB,oBAAoB,GACpB,OAAO,GACP,SAAS,GACT,MAAM,GACN,MAAM,GACN,WAAW,GACX,sBAAsB,GACtB,aAAa,GACb,YAAY,GACZ,aAAa,GACb,QAAQ,GACR,SAAS,GACT,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,QAAQ,GACR,kBAAkB,GAClB,mBAAmB,GACnB,gBAAgB,GAChB,cAAc,GACd,eAAe,GACf,WAAW,GACX,kBAAkB,GAClB,OAAO,GACP,YAAY,CAAC;AAEjB,gGAAgG;AAChG,KAAK,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AAE9E,KAAK,OAAO,GACR;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;CAAE,GACzF;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,uFAAuF;AACvF,KAAK,QAAQ,GAAG,OAAO,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;AAErE;;GAEG;AACH,QAAA,MAAM,IAAI,aAAc,MAAM,gBAAgB,YAAY,KAAG,OAI3D,CAAC;AAEH,QAAA,MAAM,MAAM,YAAa,MAAM,eAAe,KAAK,CAAC,QAAQ,CAAC,KAAG,OAI9D,CAAC;AAEH,QAAA,MAAM,UAAU,SAAU,MAAM,KAAG,OAAsC,CAAC;AAiB1E;;;;;GAKG;AACH,QAAA,MAAM,QAAQ,aAAc,KAAK,CAAC,QAAQ,CAAC,SAAS,MAAM,QAAQ,IAAI,KAAG,IA8BxE,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC9C,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC"}

package/build/markup/css.js

@@ -0,0 +1,64 @@
+import { INDENT, indentAt } from './serialize.js';
+/**
+ * Selectors stay free-form: they compose (`.badge rect`), and a keyframe stop is one too (`from`).
+ */
+const rule = (selector, declarations) => ({
+    kind: 'rule',
+    selector,
+    declarations,
+});
+const atRule = (prelude, ...children) => ({
+    kind: 'at',
+    prelude,
+    children,
+});
+const cssComment = (text) => ({ kind: 'comment', text });
+/** Drops the rules that carry nothing and flattens the arrays. */
+const flatten = (children, into = []) => {
+    for (const child of children) {
+        if (!child) {
+            continue;
+        }
+        if (Array.isArray(child)) {
+            flatten(child, into);
+        }
+        else {
+            into.push(child);
+        }
+    }
+    return into;
+};
+/**
+ * Serializes a stylesheet, dropping every rule that would have come out empty.
+ *
+ * A block is written optimistically and rewound if its body turns out empty,
+ * so the tree is walked once however deeply the at-rules nest.
+ */
+const writeCss = (children, depth, sink) => {
+    const indent = indentAt(depth);
+    for (const node of flatten(children)) {
+        if (node.kind === 'comment') {
+            sink.out += `${indent}/* ${node.text} */\n`;
+            continue;
+        }
+        const mark = sink.out.length;
+        if (node.kind === 'at') {
+            sink.out += `${indent}${node.prelude} {\n`;
+            const bodyStart = sink.out.length;
+            writeCss(node.children, depth + 1, sink);
+            sink.out =
+                sink.out.length === bodyStart ? sink.out.slice(0, mark) : `${sink.out}${indent}}\n`;
+            continue;
+        }
+        sink.out += `${indent}${node.selector} {\n`;
+        const bodyStart = sink.out.length;
+        for (const property of Object.keys(node.declarations)) {
+            const value = node.declarations[property];
+            if (value !== undefined) {
+                sink.out += `${indent}${INDENT}${property}: ${String(value)};\n`;
+            }
+        }
+        sink.out = sink.out.length === bodyStart ? sink.out.slice(0, mark) : `${sink.out}${indent}}\n`;
+    }
+};
+export { atRule, cssComment, rule, writeCss };

package/build/markup/element.d.ts

@@ -0,0 +1,41 @@
+import type { CssChild } from './css.ts';
+/**
+ * Every element a card draws, closed so `el('circel', …)` is a compile error.
+ * `style` is absent on purpose: it comes from `style()`, which takes rules rather than children.
+ */
+type Tag = 'a' | 'circle' | 'defs' | 'desc' | 'div' | 'foreignObject' | 'g' | 'linearGradient' | 'mask' | 'path' | 'rect' | 'stop' | 'svg' | 'text' | 'title' | 'tspan';
+/**
+ * Every attribute a card writes, closed like `Tag`:
+ * a misspelled `stroke-width` would otherwise be valid TypeScript and invisible in the output.
+ */
+type Attribute = 'alignment-baseline' | 'aria-hidden' | 'aria-labelledby' | 'class' | 'cx' | 'cy' | 'd' | 'data-testid' | 'data-view-component' | 'dominant-baseline' | 'dy' | 'fill' | 'fill-rule' | 'gradientTransform' | 'gradientUnits' | 'height' | 'href' | 'id' | 'mask' | 'offset' | 'r' | 'role' | 'rx' | 'ry' | 'size' | 'stop-color' | 'stroke' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-linecap' | 'stroke-opacity' | 'stroke-width' | 'style' | 'text-anchor' | 'transform' | 'version' | 'viewBox' | 'width' | 'x' | 'xmlns' | 'y';
+/** An attribute whose value is `undefined` is not written, so a caller can inline a condition. */
+type Attributes = Partial<Record<Attribute, string | number | undefined>>;
+interface MarkupElement {
+    readonly tag: Tag;
+    readonly attributes: Attributes;
+    readonly children: Array<Child>;
+}
+interface StyleElement {
+    readonly tag: 'style';
+    readonly rules: Array<CssChild>;
+}
+/** Anything accepted as content; falsy entries drop out, arrays flatten, strings are escaped. */
+type Child = MarkupElement | StyleElement | string | number | false | null | undefined | Array<Child>;
+/**
+ * Builds one element. Attribute values and text children are encoded on the way out.
+ */
+declare const el: (tag: Tag, attributes?: Attributes, ...children: Array<Child>) => MarkupElement;
+/**
+ * Builds the `<style>` element from a stylesheet rather than from text.
+ */
+declare const style: (...rules: Array<CssChild>) => StyleElement;
+/**
+ * Serializes a finished card: one element per line, two spaces per nesting level.
+ *
+ * @returns The rendered SVG.
+ */
+declare const renderMarkup: (root: MarkupElement) => string;
+export { el, renderMarkup, style };
+export type { Child, MarkupElement };
+//# sourceMappingURL=element.d.ts.map

package/build/markup/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../../src/markup/element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAMzC;;;GAGG;AACH,KAAK,GAAG,GACJ,GAAG,GACH,QAAQ,GACR,MAAM,GACN,MAAM,GACN,KAAK,GACL,eAAe,GACf,GAAG,GACH,gBAAgB,GAChB,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,KAAK,GACL,MAAM,GACN,OAAO,GACP,OAAO,CAAC;AAEZ;;;GAGG;AACH,KAAK,SAAS,GACV,oBAAoB,GACpB,aAAa,GACb,iBAAiB,GACjB,OAAO,GACP,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,aAAa,GACb,qBAAqB,GACrB,mBAAmB,GACnB,IAAI,GACJ,MAAM,GACN,WAAW,GACX,mBAAmB,GACnB,eAAe,GACf,QAAQ,GACR,MAAM,GACN,IAAI,GACJ,MAAM,GACN,QAAQ,GACR,GAAG,GACH,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,kBAAkB,GAClB,mBAAmB,GACnB,gBAAgB,GAChB,gBAAgB,GAChB,cAAc,GACd,OAAO,GACP,aAAa,GACb,WAAW,GACX,SAAS,GACT,SAAS,GACT,OAAO,GACP,GAAG,GACH,OAAO,GACP,GAAG,CAAC;AAER,kGAAkG;AAClG,KAAK,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AAK1E,UAAU,aAAa;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;CACjC;AAED,UAAU,YAAY;IACpB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;CACjC;AAED,iGAAiG;AACjG,KAAK,KAAK,GACN,aAAa,GACb,YAAY,GACZ,MAAM,GACN,MAAM,GACN,KAAK,GACL,IAAI,GACJ,SAAS,GACT,KAAK,CAAC,KAAK,CAAC,CAAC;AAKjB;;GAEG;AACH,QAAA,MAAM,EAAE,QAAS,GAAG,eAAc,UAAU,eAAoB,KAAK,CAAC,KAAK,CAAC,KAAG,aAI7E,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,KAAK,aAAc,KAAK,CAAC,QAAQ,CAAC,KAAG,YAAyC,CAAC;AAmHrF;;;;GAIG;AACH,QAAA,MAAM,YAAY,SAAU,aAAa,KAAG,MAI3C,CAAC;AAEF,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;AACnC,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC"}

package/build/markup/element.js

@@ -0,0 +1,127 @@
+import { writeCss } from './css.js';
+import { encodeHTML } from './html.js';
+import { indentAt } from './serialize.js';
+/** Elements whose character data is part of the rendering, so they stay on one line. */
+const INLINE_ELEMENTS = new Set(['text', 'tspan', 'title', 'desc', 'div']);
+/**
+ * Builds one element. Attribute values and text children are encoded on the way out.
+ */
+const el = (tag, attributes = {}, ...children) => ({
+    tag,
+    attributes,
+    children,
+});
+/**
+ * Builds the `<style>` element from a stylesheet rather than from text.
+ */
+const style = (...rules) => ({ tag: 'style', rules });
+const isStyle = (child) => 'rules' in child;
+/** Drops the children that carry nothing and flattens the arrays. */
+const flatten = (children, into = []) => {
+    for (const child of children) {
+        if (child === false || child === null || child === undefined || child === '') {
+            continue;
+        }
+        if (Array.isArray(child)) {
+            flatten(child, into);
+        }
+        else {
+            into.push(child);
+        }
+    }
+    return into;
+};
+const openTag = (node, selfClosing) => {
+    let tag = `<${node.tag}`;
+    const { attributes } = node;
+    // `Object.keys` widens to `string`, so the cast restores what the type already says.
+    for (const name of Object.keys(attributes)) {
+        const value = attributes[name];
+        if (value !== undefined) {
+            // A number can hold nothing that needs escaping, so it skips the scan.
+            tag += typeof value === 'number' ? ` ${name}="${value}"` : ` ${name}="${encodeHTML(value)}"`;
+        }
+    }
+    return `${tag}${selfClosing ? ' />' : '>'}`;
+};
+/** Serializes an element and its descendants onto one line, whitespace and all. */
+const writeInline = (node) => {
+    if (typeof node === 'string') {
+        return encodeHTML(node);
+    }
+    if (typeof node === 'number') {
+        return String(node);
+    }
+    if (isStyle(node)) {
+        return '';
+    }
+    const children = flatten(node.children);
+    if (children.length === 0) {
+        return openTag(node, true);
+    }
+    let inner = '';
+    for (const child of children) {
+        inner += writeInline(child);
+    }
+    return `${openTag(node, false)}${inner}</${node.tag}>`;
+};
+/**
+ * A container is written optimistically and rewound if its content turns out empty,
+ * so an element that draws nothing costs one walk rather than two.
+ */
+const write = (node, depth, sink) => {
+    const indent = indentAt(depth);
+    if (typeof node === 'string') {
+        sink.out += `${indent}${encodeHTML(node)}\n`;
+        return;
+    }
+    if (typeof node === 'number') {
+        sink.out += `${indent}${node}\n`;
+        return;
+    }
+    const mark = sink.out.length;
+    if (isStyle(node)) {
+        sink.out += `${indent}<style>\n`;
+        const bodyStart = sink.out.length;
+        writeCss(node.rules, depth + 1, sink);
+        sink.out =
+            sink.out.length === bodyStart ? sink.out.slice(0, mark) : `${sink.out}${indent}</style>\n`;
+        return;
+    }
+    const children = flatten(node.children);
+    if (children.length === 0) {
+        sink.out += `${indent}${openTag(node, true)}\n`;
+        return;
+    }
+    if (INLINE_ELEMENTS.has(node.tag)) {
+        let inner = '';
+        for (const child of children) {
+            inner += writeInline(child);
+        }
+        sink.out +=
+            inner === ''
+                ? `${indent}${openTag(node, true)}\n`
+                : `${indent}${openTag(node, false)}${inner}</${node.tag}>\n`;
+        return;
+    }
+    sink.out += `${indent}${openTag(node, false)}\n`;
+    const bodyStart = sink.out.length;
+    for (const child of children) {
+        write(child, depth + 1, sink);
+    }
+    sink.out =
+        sink.out.length === bodyStart
+            ? `${sink.out.slice(0, mark)}${indent}${openTag(node, true)}\n`
+            : `${sink.out}${indent}</${node.tag}>\n`;
+};
+/**
+ * Serializes a finished card: one element per line, two spaces per nesting level.
+ *
+ * @returns The rendered SVG.
+ */
+const renderMarkup = (root) => {
+    const sink = { out: '' };
+    write(root, 0, sink);
+    return sink.out;
+};
+export { el, renderMarkup, style };

package/build/markup/html.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Encodes a string for use as markup, one numeric character reference each.
+ *
+ * The serializer is now the only place text becomes markup, so nothing arrives pre-escaped:
+ * a literal `&` is encoded like any other `&` rather than passed through as a reference.
+ *
+ * @see https://stackoverflow.com/a/48073476/10629172
+ *
+ * @returns The text, safe to place in an attribute or as character data.
+ */
+declare const encodeHTML: (str: string) => string;
+export { encodeHTML };
+//# sourceMappingURL=html.d.ts.map

package/build/markup/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/markup/html.ts"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,QAAS,MAAM,KAAG,MASjC,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/build/markup/html.js

@@ -0,0 +1,27 @@
+/**
+ * What has to be encoded: the markup characters, everything above plain ASCII, and a backspace.
+ * One source for both regexes, so the check and the replacement cannot disagree.
+ */
+const ENCODED = String.raw `[<>&"'\u00A0-\u9999\u0008]`;
+/** Non-global, so `.test` stays stateless: a global regex would carry `lastIndex`. */
+const NEEDS_ENCODING = new RegExp(ENCODED);
+const TO_ENCODE = new RegExp(ENCODED, 'g');
+const BACKSPACE = '\u0008';
+/**
+ * Encodes a string for use as markup, one numeric character reference each.
+ *
+ * The serializer is now the only place text becomes markup, so nothing arrives pre-escaped:
+ * a literal `&#38;` is encoded like any other `&` rather than passed through as a reference.
+ *
+ * @see https://stackoverflow.com/a/48073476/10629172
+ *
+ * @returns The text, safe to place in an attribute or as character data.
+ */
+const encodeHTML = (str) => {
+    // Most strings a card writes are plain ASCII, so they leave without a rewrite.
+    if (!NEEDS_ENCODING.test(str)) {
+        return str;
+    }
+    return str.replace(TO_ENCODE, (char) => char === BACKSPACE ? '' : `&#${char.codePointAt(0) ?? 0};`);
+};
+export { encodeHTML };

package/build/markup/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The markup layer: a card is built as a tree of elements and rules, then serialized once.
+ * It depends on nothing else in the package, so it sits below `cards/`, not inside `common/`.
+ */
+export { atRule, cssComment, rule } from './css.ts';
+export type { CssChild, Declarations } from './css.ts';
+export { el, renderMarkup, style } from './element.ts';
+export type { Child, MarkupElement } from './element.ts';
+//# sourceMappingURL=index.d.ts.map

package/build/markup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markup/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACpD,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/build/markup/index.js

@@ -0,0 +1,6 @@
+/**
+ * The markup layer: a card is built as a tree of elements and rules, then serialized once.
+ * It depends on nothing else in the package, so it sits below `cards/`, not inside `common/`.
+ */
+export { atRule, cssComment, rule } from './css.js';
+export { el, renderMarkup, style } from './element.js';

package/build/markup/serialize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What the markup and stylesheet serializers share: where output goes, and how deep a line sits.
+ * Both write into one growing string rather than a list of chunks, so nothing needs joining.
+ */
+declare const INDENT = "  ";
+/** Collects serializer output. A plain holder so appends stay a property write. */
+interface Sink {
+    out: string;
+}
+/**
+ * @returns Two spaces per level.
+ */
+declare const indentAt: (depth: number) => string;
+export { INDENT, indentAt };
+export type { Sink };
+//# sourceMappingURL=serialize.d.ts.map

package/build/markup/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/markup/serialize.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,QAAA,MAAM,MAAM,OAAO,CAAC;AAEpB,mFAAmF;AACnF,UAAU,IAAI;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAKD;;GAEG;AACH,QAAA,MAAM,QAAQ,UAAW,MAAM,KAAG,MAKjC,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC5B,YAAY,EAAE,IAAI,EAAE,CAAC"}

package/build/markup/serialize.js

@@ -0,0 +1,17 @@
+/**
+ * What the markup and stylesheet serializers share: where output goes, and how deep a line sits.
+ * Both write into one growing string rather than a list of chunks, so nothing needs joining.
+ */
+const INDENT = '  ';
+/** Indentation by depth, grown as the tree is walked rather than rebuilt per line. */
+const indents = ['', INDENT];
+/**
+ * @returns Two spaces per level.
+ */
+const indentAt = (depth) => {
+    for (let i = indents.length; i <= depth; i += 1) {
+        indents.push(`${indents[i - 1] ?? ''}${INDENT}`);
+    }
+    return indents[depth] ?? '';
+};
+export { INDENT, indentAt };