@syware/jlib 0.0.0-stage → 0.1.0

package/dist/lib/numeric.js

@@ -0,0 +1,50 @@
+// src/lib/numeric.ts
+var NO_DECIMALS = 0;
+/** A number written in a field or an attribute; empty or unreadable text gives null. */
+function parseNumber(text) {
+	if (text === null || text.trim() === "") return null;
+	const parsed = Number(text.trim());
+	return Number.isFinite(parsed) ? parsed : null;
+}
+/** A number kept within bounds; a null bound does not limit that side. */
+function clamp(value, min, max) {
+	const floored = min === null ? value : Math.max(min, value);
+	return max === null ? floored : Math.min(max, floored);
+}
+/** How many decimals a number has as written: 0.25 has 2, so sums of steps print without float noise. */
+function decimalsOf(value) {
+	if (!Number.isFinite(value) || Number.isInteger(value)) return NO_DECIMALS;
+	const [mantissa = "", exponent = "0"] = String(value).split("e");
+	const decimals = mantissa.split(".")[1]?.length ?? NO_DECIMALS;
+	return Math.max(NO_DECIMALS, decimals - Number(exponent));
+}
+function roundTo(value, decimals) {
+	return Number(value.toFixed(decimals));
+}
+/**
+* The value one step up or down, within bounds, rounded to the decimals of the step and the value. An empty value
+* counts as zero.
+*/
+function stepValue(value, step, direction, min, max) {
+	const start = value ?? 0;
+	const decimals = Math.max(decimalsOf(step), decimalsOf(start));
+	return clamp(roundTo(start + step * direction, decimals), min, max);
+}
+/** Where a value sits between min and max, from 0 to 1; an empty range gives 0. */
+function fractionOf(value, min, max) {
+	if (max <= min) return 0;
+	return clamp((value - min) / (max - min), 0, 1);
+}
+var isMarkObject = (mark) => typeof mark === "object" && mark !== null && typeof mark.value === "number";
+/**
+* The marks of a slider from what a page wrote: numbers (`[0, 50, 100]`) or objects with a label
+* (`[{ "value": 0, "label": "Off" }]`). Marks outside the range and unreadable entries are left out.
+*/
+function marksOf(raw, min, max) {
+	if (!Array.isArray(raw)) return [];
+	return raw.map((mark) => {
+		if (typeof mark === "number") return { value: mark };
+		return isMarkObject(mark) ? mark : null;
+	}).filter((mark) => mark !== null && mark.value >= min && mark.value <= max);
+}
+export { clamp, decimalsOf, fractionOf, marksOf, parseNumber, roundTo, stepValue };

package/dist/lib/option-filter.d.ts

@@ -0,0 +1,29 @@
+import type { TextMatch, TextMatchPart } from '../types/option-filter.types';
+/** A text as matching sees it: "Crème Brûlée" gives "creme brulee". */
+export declare const foldText: (text: string) => string;
+/**
+ * Where a search first occurs in a text, ignoring case and accents, in the text's own indexes; null when it does
+ * not, or when the search is empty.
+ */
+export declare function findMatch(text: string, query: string): TextMatch | null;
+/** A text cut around its match, so the matched piece can be drawn highlighted. */
+export declare function matchParts(text: string, query: string): TextMatchPart[];
+/**
+ * The options whose label contains the search, ignoring case and accents: those that start with it first, then
+ * those with a word that starts with it, then the rest, each group in its original order. An empty search keeps
+ * every option.
+ */
+export declare function filterOptions<Option extends {
+    label: string;
+}>(options: readonly Option[], query: string): Option[];
+/**
+ * The index of the next option that can be chosen, going down (1) or up (-1) from the current one and wrapping
+ * around the ends; from -1 (none active) it starts at the first or the last. -1 when none can be chosen.
+ */
+export declare function nextEnabledIndex(options: readonly {
+    disabled?: boolean;
+}[], current: number, direction: 1 | -1): number;
+/** The first (1) or last (-1) option that can be chosen; -1 when none can. */
+export declare const edgeEnabledIndex: (options: readonly {
+    disabled?: boolean;
+}[], from: 1 | -1) => number;

package/dist/lib/option-filter.js

@@ -0,0 +1,108 @@
+// src/lib/option-filter.ts
+/** How well a label matches: at its start, at the start of one of its words, or anywhere inside. */
+var RANK = {
+	anywhere: 2,
+	labelStart: 0,
+	wordStart: 1
+};
+var DIACRITICS = /\p{Diacritic}/gu;
+var WORD_CHARACTER = /[\p{L}\p{N}]/u;
+/** One character as matching sees it: lower case, without its accents ("É" gives "e"). */
+var foldCharacter = (character) => character.normalize("NFD").replace(DIACRITICS, "").toLowerCase();
+/** A text as matching sees it: "Crème Brûlée" gives "creme brulee". */
+var foldText = (text) => Array.from(text, foldCharacter).join("");
+function foldPieces(text) {
+	const pieces = [];
+	const offsets = {
+		folded: 0,
+		original: 0
+	};
+	for (const character of text) {
+		const folded = foldCharacter(character);
+		pieces.push({
+			end: offsets.original + character.length,
+			foldedEnd: offsets.folded + folded.length,
+			foldedStart: offsets.folded,
+			start: offsets.original
+		});
+		offsets.original += character.length;
+		offsets.folded += folded.length;
+	}
+	return pieces;
+}
+/**
+* Where a search first occurs in a text, ignoring case and accents, in the text's own indexes; null when it does
+* not, or when the search is empty.
+*/
+function findMatch(text, query) {
+	const needle = foldText(query.trim());
+	if (needle === "") return null;
+	const at = foldText(text).indexOf(needle);
+	if (at < 0) return null;
+	const end = at + needle.length;
+	const pieces = foldPieces(text);
+	const first = pieces.find((piece) => piece.foldedEnd > at);
+	const last = pieces.findLast((piece) => piece.foldedStart < end || piece.foldedEnd === end);
+	if (first === void 0 || last === void 0) return null;
+	return {
+		end: last.end,
+		start: first.start
+	};
+}
+/** A text cut around its match, so the matched piece can be drawn highlighted. */
+function matchParts(text, query) {
+	const match = findMatch(text, query);
+	if (match === null) return text === "" ? [] : [{
+		matched: false,
+		text
+	}];
+	return [
+		{
+			matched: false,
+			text: text.slice(0, match.start)
+		},
+		{
+			matched: true,
+			text: text.slice(match.start, match.end)
+		},
+		{
+			matched: false,
+			text: text.slice(match.end)
+		}
+	].filter((part) => part.text !== "");
+}
+var startsAWord = (folded, index) => index === 0 || !WORD_CHARACTER.test(folded.charAt(index - 1));
+/** How well a label matches a folded search, or null when it does not contain it. */
+function rankOf(label, needle) {
+	const folded = foldText(label);
+	const first = folded.indexOf(needle);
+	if (first < 0) return null;
+	if (first === 0) return RANK.labelStart;
+	return Array.from(folded, (_, index) => index).filter((index) => folded.startsWith(needle, index)).some((index) => startsAWord(folded, index)) ? RANK.wordStart : RANK.anywhere;
+}
+/**
+* The options whose label contains the search, ignoring case and accents: those that start with it first, then
+* those with a word that starts with it, then the rest, each group in its original order. An empty search keeps
+* every option.
+*/
+function filterOptions(options, query) {
+	const needle = foldText(query.trim());
+	if (needle === "") return [...options];
+	return options.map((option, index) => ({
+		index,
+		option,
+		rank: rankOf(option.label, needle)
+	})).filter((entry) => entry.rank !== null).sort((a, b) => a.rank - b.rank || a.index - b.index).map((entry) => entry.option);
+}
+/**
+* The index of the next option that can be chosen, going down (1) or up (-1) from the current one and wrapping
+* around the ends; from -1 (none active) it starts at the first or the last. -1 when none can be chosen.
+*/
+function nextEnabledIndex(options, current, direction) {
+	const count = options.length;
+	const start = current < 0 && direction < 0 ? count : current;
+	return Array.from({ length: count }, (_, step) => ((start + direction * (step + 1)) % count + count) % count).find((index) => options[index]?.disabled !== true) ?? -1;
+}
+/** The first (1) or last (-1) option that can be chosen; -1 when none can. */
+var edgeEnabledIndex = (options, from) => nextEnabledIndex(options, -1, from);
+export { edgeEnabledIndex, filterOptions, findMatch, foldText, matchParts, nextEnabledIndex };

package/dist/lib/option-groups.d.ts

@@ -0,0 +1,6 @@
+import type { SelectOption, SelectOptionGroup } from '../types/jl-select.types';
+/**
+ * Options laid out as a select draws them: the options of a group gather under it, where the group first appears;
+ * options without a group stay in place, between the groups.
+ */
+export declare function groupOptions(options: readonly SelectOption[]): SelectOptionGroup[];

package/dist/lib/option-groups.js

@@ -0,0 +1,26 @@
+// src/lib/option-groups.ts
+/**
+* Options laid out as a select draws them: the options of a group gather under it, where the group first appears;
+* options without a group stay in place, between the groups.
+*/
+function groupOptions(options) {
+	const groups = [];
+	for (const option of options) {
+		const label = option.group ?? null;
+		const target = label === null ? lastIfUngrouped(groups) : groups.find((group) => group.label === label);
+		if (target === void 0) {
+			groups.push({
+				label,
+				options: [option]
+			});
+			continue;
+		}
+		target.options.push(option);
+	}
+	return groups;
+}
+var lastIfUngrouped = (groups) => {
+	const last = groups.at(-1);
+	return last?.label === null ? last : void 0;
+};
+export { groupOptions };

package/dist/lib/options.d.ts

@@ -0,0 +1,5 @@
+import type { ControlSize, Tone } from '../types/options.types';
+export declare const TONES: readonly Tone[];
+export declare const CONTROL_SIZES: readonly ControlSize[];
+/** The icon that says each tone at a glance: alerts, toasts and callouts use it. */
+export declare const TONE_ICONS: Record<Tone, string>;

package/dist/lib/options.js

@@ -0,0 +1,24 @@
+// src/lib/options.ts
+var TONES = [
+	"neutral",
+	"accent",
+	"ok",
+	"warn",
+	"danger",
+	"info"
+];
+var CONTROL_SIZES = [
+	"md",
+	"sm",
+	"lg"
+];
+/** The icon that says each tone at a glance: alerts, toasts and callouts use it. */
+var TONE_ICONS = {
+	accent: "sparkles",
+	danger: "circle-x",
+	info: "info",
+	neutral: "info",
+	ok: "circle-check",
+	warn: "triangle-alert"
+};
+export { CONTROL_SIZES, TONES, TONE_ICONS };

package/dist/lib/pagination.d.ts

@@ -0,0 +1,9 @@
+import type { PageItem } from '../types/pagination.types';
+/** A page number kept within 1 and the last page; a missing or unreadable one is the first page. */
+export declare function clampPage(page: number, pages: number): number;
+/**
+ * The entries of a pagination: the first and the last `boundaries` pages, the current page with `siblings` pages
+ * on each side, and gaps for the pages between. The list has the same length on every page, so the buttons do not
+ * move under the pointer while people step through.
+ */
+export declare function pageItems(page: number, pages: number, siblings?: number, boundaries?: number): PageItem[];

package/dist/lib/pagination.js

@@ -0,0 +1,52 @@
+// src/lib/pagination.ts
+var FIRST_PAGE = 1;
+var range = (start, end) => end < start ? [] : Array.from({ length: end - start + 1 }, (_, index) => start + index);
+var pageItem = (page) => ({
+	page,
+	type: "page"
+});
+/** A page number kept within 1 and the last page; a missing or unreadable one is the first page. */
+function clampPage(page, pages) {
+	if (Number.isNaN(page) || pages < FIRST_PAGE) return FIRST_PAGE;
+	return Math.min(Math.max(Math.round(page), FIRST_PAGE), pages);
+}
+/** Between the first pages and the siblings: a gap, the one page a gap would hide, or nothing. */
+function startJoint(siblingsStart, boundaries, pages) {
+	if (siblingsStart > boundaries + 2) return [{
+		side: "start",
+		type: "gap"
+	}];
+	if (boundaries + 1 < pages - boundaries) return [pageItem(boundaries + 1)];
+	return [];
+}
+/** Between the siblings and the last pages: a gap, the one page a gap would hide, or nothing. */
+function endJoint(siblingsEnd, boundaries, pages) {
+	if (siblingsEnd < pages - boundaries - 1) return [{
+		side: "end",
+		type: "gap"
+	}];
+	if (pages - boundaries > boundaries) return [pageItem(pages - boundaries)];
+	return [];
+}
+/**
+* The entries of a pagination: the first and the last `boundaries` pages, the current page with `siblings` pages
+* on each side, and gaps for the pages between. The list has the same length on every page, so the buttons do not
+* move under the pointer while people step through.
+*/
+function pageItems(page, pages, siblings = 1, boundaries = 1) {
+	if (pages < FIRST_PAGE) return [];
+	const current = clampPage(page, pages);
+	const startPages = range(FIRST_PAGE, Math.min(boundaries, pages));
+	const endPages = range(Math.max(pages - boundaries + 1, boundaries + 1), pages);
+	const siblingsStart = Math.max(Math.min(current - siblings, pages - boundaries - siblings * 2 - 1), boundaries + 2);
+	const lastBeforeEnd = endPages.length > 0 ? (endPages[0] ?? pages) - 2 : pages - 1;
+	const siblingsEnd = Math.min(Math.max(current + siblings, boundaries + siblings * 2 + 2), lastBeforeEnd);
+	return [
+		...startPages.map(pageItem),
+		...startJoint(siblingsStart, boundaries, pages),
+		...range(siblingsStart, siblingsEnd).map(pageItem),
+		...endJoint(siblingsEnd, boundaries, pages),
+		...endPages.map(pageItem)
+	];
+}
+export { clampPage, pageItems };

package/dist/lib/palette.d.ts

@@ -0,0 +1,8 @@
+import type { PaletteCommand, PaletteGroup, PaletteMatch } from '../types/jl-command-palette.types';
+/**
+ * The commands that match the search, best first; an empty search keeps them all in their order. The label's
+ * matched letters come with each, for highlighting; a command found by a keyword only has none.
+ */
+export declare function matchCommands(commands: readonly PaletteCommand[], query: string): PaletteMatch[];
+/** The matches under their group headings, groups in the order their first command comes. */
+export declare function groupMatches(matches: readonly PaletteMatch[]): PaletteGroup[];

package/dist/lib/palette.js

@@ -0,0 +1,46 @@
+import { fuzzyMatch } from "./fuzzy.js";
+// src/lib/palette.ts
+/** A match on a keyword counts less than one on the label people read. */
+var KEYWORD_WEIGHT = .5;
+var NO_GROUP = "";
+function keywordScore(query, keywords) {
+	const scores = keywords.map((keyword) => fuzzyMatch(query, keyword)?.score).filter((score) => score !== void 0);
+	return scores.length === 0 ? null : Math.max(...scores) * KEYWORD_WEIGHT;
+}
+function matchCommand(query, command) {
+	const label = fuzzyMatch(query, command.label);
+	const keyword = keywordScore(query, command.keywords ?? []);
+	if (label === null && keyword === null) return null;
+	if (label === null) return {
+		command,
+		positions: [],
+		score: keyword ?? 0
+	};
+	return {
+		command,
+		positions: label.positions,
+		score: Math.max(label.score, keyword ?? label.score)
+	};
+}
+/**
+* The commands that match the search, best first; an empty search keeps them all in their order. The label's
+* matched letters come with each, for highlighting; a command found by a keyword only has none.
+*/
+function matchCommands(commands, query) {
+	const matches = commands.map((command) => matchCommand(query, command)).filter((match) => match !== null);
+	if (query.trim() === "") return matches;
+	return matches.sort((a, b) => b.score - a.score);
+}
+/** The matches under their group headings, groups in the order their first command comes. */
+function groupMatches(matches) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const match of matches) {
+		const label = match.command.group ?? NO_GROUP;
+		groups.set(label, [...groups.get(label) ?? [], match]);
+	}
+	return [...groups].map(([label, grouped]) => ({
+		label,
+		matches: grouped
+	}));
+}
+export { groupMatches, matchCommands };

package/dist/lib/progress.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A number attribute that may be absent: `null` when it is missing or unreadable. A progress without a value is
+ * indeterminate.
+ */
+export declare const optionalNumber: (value: string | null) => number | null;
+/** How far along a value is, from 0 to 1; a maximum of 0 or less counts as no progress. */
+export declare function progressRatio(value: number, max: number): number;
+/** A ratio as the percentage people read: 0.456 gives "46%". */
+export declare const percentLabel: (ratio: number) => string;
+/** A ratio in percent, for a path drawn with `pathLength="100"`: 0.25 gives 25. */
+export declare const percentOf: (ratio: number) => number;
+/**
+ * The circle of a progress ring of `size` pixels, its stroke `thickness` wide: the stroke stays inside the box,
+ * and is at most half the size.
+ */
+export declare function ringGeometry(size: number, thickness: number): {
+    center: number;
+    radius: number;
+    stroke: number;
+};

package/dist/lib/progress.js

@@ -0,0 +1,33 @@
+// src/lib/progress.ts
+var PERCENT = 100;
+/**
+* A number attribute that may be absent: `null` when it is missing or unreadable. A progress without a value is
+* indeterminate.
+*/
+var optionalNumber = (value) => {
+	const parsed = value === null || value.trim() === "" ? NaN : Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+};
+/** How far along a value is, from 0 to 1; a maximum of 0 or less counts as no progress. */
+function progressRatio(value, max) {
+	if (!(max > 0) || !Number.isFinite(value)) return 0;
+	return Math.min(1, Math.max(0, value / max));
+}
+/** A ratio as the percentage people read: 0.456 gives "46%". */
+var percentLabel = (ratio) => `${Math.round(ratio * PERCENT)}%`;
+/** A ratio in percent, for a path drawn with `pathLength="100"`: 0.25 gives 25. */
+var percentOf = (ratio) => ratio * PERCENT;
+/**
+* The circle of a progress ring of `size` pixels, its stroke `thickness` wide: the stroke stays inside the box,
+* and is at most half the size.
+*/
+function ringGeometry(size, thickness) {
+	const box = Math.max(0, size);
+	const stroke = Math.min(Math.max(0, thickness), box / 2);
+	return {
+		center: box / 2,
+		radius: (box - stroke) / 2,
+		stroke
+	};
+}
+export { optionalNumber, percentLabel, percentOf, progressRatio, ringGeometry };

package/dist/lib/rating.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The rating a key gives, as a slider reads keys: right and up add one, left and down take one, Home empties it,
+ * End fills it, a digit sets that many (when it fits). Null for any other key.
+ */
+export declare function ratingAfterKey(value: number, key: string, max: number): number | null;
+/** Choosing the rating already given clears it: a second press on the third star leaves none. */
+export declare const ratingAfterChoice: (value: number, chosen: number) => number;

package/dist/lib/rating.js

@@ -0,0 +1,26 @@
+// src/lib/rating.ts
+var DIGIT = /^\d$/;
+/** A digit key sets that many, when the scale has room for it. */
+function ratingOfDigit(key, max) {
+	const rating = Number(key);
+	return rating <= max ? rating : null;
+}
+/**
+* The rating a key gives, as a slider reads keys: right and up add one, left and down take one, Home empties it,
+* End fills it, a digit sets that many (when it fits). Null for any other key.
+*/
+function ratingAfterKey(value, key, max) {
+	if (DIGIT.test(key)) return ratingOfDigit(key, max);
+	const next = (/* @__PURE__ */ new Map([
+		["ArrowDown", value - 1],
+		["ArrowLeft", value - 1],
+		["ArrowRight", value + 1],
+		["ArrowUp", value + 1],
+		["End", max],
+		["Home", 0]
+	])).get(key);
+	return next === void 0 ? null : Math.min(max, Math.max(0, next));
+}
+/** Choosing the rating already given clears it: a second press on the third star leaves none. */
+var ratingAfterChoice = (value, chosen) => chosen === value ? 0 : chosen;
+export { ratingAfterChoice, ratingAfterKey };

package/dist/lib/roving-index.d.ts

@@ -0,0 +1,10 @@
+import type { RovingMove } from '../types/roving-index.types';
+/** The first item that is not disabled, or -1 when every item is. */
+export declare function firstEnabledIndex(disabled: readonly boolean[]): number;
+/** The last item that is not disabled, or -1 when every item is. */
+export declare function lastEnabledIndex(disabled: readonly boolean[]): number;
+/**
+ * Where a move goes from the item at `from`, skipping disabled items as native radios do. From nowhere (-1), next
+ * starts at the first item and previous at the last.
+ */
+export declare function rovingIndex(disabled: readonly boolean[], from: number, move: RovingMove): number;

package/dist/lib/roving-index.js

@@ -0,0 +1,32 @@
+// src/lib/roving-index.ts
+var NONE = -1;
+/** The first item that is not disabled, or -1 when every item is. */
+function firstEnabledIndex(disabled) {
+	return disabled.indexOf(false);
+}
+/** The last item that is not disabled, or -1 when every item is. */
+function lastEnabledIndex(disabled) {
+	return disabled.lastIndexOf(false);
+}
+/** The next enabled item after `from` in a direction, wrapping around the ends; -1 when none is enabled. */
+function steppedIndex(disabled, from, step) {
+	const count = disabled.length;
+	for (let offset = 1; offset <= count; offset += 1) {
+		const index = ((from + step * offset) % count + count) % count;
+		if (disabled[index] === false) return index;
+	}
+	return NONE;
+}
+/**
+* Where a move goes from the item at `from`, skipping disabled items as native radios do. From nowhere (-1), next
+* starts at the first item and previous at the last.
+*/
+function rovingIndex(disabled, from, move) {
+	return {
+		first: () => firstEnabledIndex(disabled),
+		last: () => lastEnabledIndex(disabled),
+		next: () => steppedIndex(disabled, from, 1),
+		previous: () => steppedIndex(disabled, from === NONE ? disabled.length : from, -1)
+	}[move]();
+}
+export { firstEnabledIndex, lastEnabledIndex, rovingIndex };

package/dist/lib/roving.d.ts

@@ -0,0 +1,11 @@
+/** The first entry that can be chosen. */
+export declare const firstIndex: (enabled: readonly boolean[]) => number;
+/** The last entry that can be chosen. */
+export declare const lastIndex: (enabled: readonly boolean[]) => number;
+/** The entry `step` places away from `from` among those that can be chosen, wrapping around the ends. */
+export declare function stepIndex(enabled: readonly boolean[], from: number, step: 1 | -1): number;
+/**
+ * Typeahead: the next entry after `from` whose label starts with the letter typed, wrapping around; the search
+ * ignores case and the spaces before the label.
+ */
+export declare function letterIndex(labels: readonly string[], enabled: readonly boolean[], from: number, letter: string): number;

package/dist/lib/roving.js

@@ -0,0 +1,21 @@
+// src/lib/roving.ts
+var NONE = -1;
+/** The first entry that can be chosen. */
+var firstIndex = (enabled) => enabled.indexOf(true);
+/** The last entry that can be chosen. */
+var lastIndex = (enabled) => enabled.lastIndexOf(true);
+var wrap = (index, count) => (index % count + count) % count;
+/** The entry `step` places away from `from` among those that can be chosen, wrapping around the ends. */
+function stepIndex(enabled, from, step) {
+	const count = enabled.length;
+	return Array.from({ length: count }, (_, offset) => wrap(from + step * (offset + 1), count)).find((index) => enabled[index] === true) ?? NONE;
+}
+/**
+* Typeahead: the next entry after `from` whose label starts with the letter typed, wrapping around; the search
+* ignores case and the spaces before the label.
+*/
+function letterIndex(labels, enabled, from, letter) {
+	const wanted = letter.toLocaleLowerCase();
+	return stepIndex(labels.map((label, index) => enabled[index] === true && label.trim().toLocaleLowerCase().startsWith(wanted)), from, 1);
+}
+export { firstIndex, lastIndex, letterIndex, stepIndex };

package/dist/lib/slots.d.ts

@@ -0,0 +1,2 @@
+/** Whether a slot holds something to show: an element, or text that is not only white space. */
+export declare function hasSlotted(slot: HTMLSlotElement): boolean;

package/dist/lib/slots.js

@@ -0,0 +1,6 @@
+// src/lib/slots.ts
+/** Whether a slot holds something to show: an element, or text that is not only white space. */
+function hasSlotted(slot) {
+	return slot.assignedNodes({ flatten: true }).some((node) => node instanceof Element || (node.textContent ?? "").trim() !== "");
+}
+export { hasSlotted };

package/dist/lib/sparkline.d.ts

@@ -0,0 +1,11 @@
+import type { SparkBox, SparkPoint } from '../types/sparkline.types';
+/**
+ * The points of a sparkline in a box: evenly spaced from left to right, the highest value at the top and the
+ * lowest at the bottom, `inset` away from the edges. One value draws a flat line across; equal values sit in the
+ * middle. Values that are not finite numbers are left out.
+ */
+export declare function sparklinePoints(values: readonly number[], box: SparkBox): SparkPoint[];
+/** Points as an SVG `points` attribute: "0,10 25,4 50,8". */
+export declare const pointsAttribute: (points: readonly SparkPoint[]) => string;
+/** The area under the line, closed along the bottom of the box, as an SVG `points` attribute. */
+export declare function areaAttribute(points: readonly SparkPoint[], box: SparkBox): string;

package/dist/lib/sparkline.js

@@ -0,0 +1,42 @@
+// src/lib/sparkline.ts
+var PRECISION = 100;
+var round = (value) => Math.round(value * PRECISION) / PRECISION;
+/**
+* The points of a sparkline in a box: evenly spaced from left to right, the highest value at the top and the
+* lowest at the bottom, `inset` away from the edges. One value draws a flat line across; equal values sit in the
+* middle. Values that are not finite numbers are left out.
+*/
+function sparklinePoints(values, box) {
+	const finite = values.filter((value) => Number.isFinite(value));
+	if (finite.length === 0) return [];
+	const series = finite.length === 1 ? [finite[0] ?? 0, finite[0] ?? 0] : finite;
+	const min = Math.min(...series);
+	const range = Math.max(...series) - min;
+	const innerWidth = box.width - box.inset * 2;
+	const innerHeight = box.height - box.inset * 2;
+	const step = innerWidth / (series.length - 1);
+	return series.map((value, index) => ({
+		x: round(box.inset + index * step),
+		y: round(range === 0 ? box.height / 2 : box.inset + (1 - (value - min) / range) * innerHeight)
+	}));
+}
+/** Points as an SVG `points` attribute: "0,10 25,4 50,8". */
+var pointsAttribute = (points) => points.map((point) => `${point.x},${point.y}`).join(" ");
+/** The area under the line, closed along the bottom of the box, as an SVG `points` attribute. */
+function areaAttribute(points, box) {
+	const first = points[0];
+	const last = points.at(-1);
+	if (first === void 0 || last === void 0) return "";
+	return pointsAttribute([
+		...points,
+		{
+			x: last.x,
+			y: box.height
+		},
+		{
+			x: first.x,
+			y: box.height
+		}
+	]);
+}
+export { areaAttribute, pointsAttribute, sparklinePoints };

package/dist/lib/split.d.ts

@@ -0,0 +1,12 @@
+import type { SplitOrientation } from '../types/jl-split-view.types';
+/** The smallest share each pane keeps, in percent: never under 0 nor over half. */
+export declare const clampMin: (min: number) => number;
+/** A divider position kept so that each pane keeps at least `min` percent. */
+export declare const clampSplit: (position: number, min: number) => number;
+/** Where a pointer sits along the split, in percent of its length from its start; the middle when it has none. */
+export declare const positionAt: (pointer: number, start: number, length: number) => number;
+/**
+ * Where a key moves the divider: arrows along the split by a step (a large one with Shift), Home and End to the
+ * ends; null for any other key.
+ */
+export declare function positionAfterKey(position: number, key: string, orientation: SplitOrientation, min: number, large?: boolean): number | null;