@514sid/signagekit 0.0.0-stage → 0.0.2

package/dist/types/colors.d.ts

@@ -0,0 +1,18 @@
+export declare const COLOR_KEYS: readonly ["background", "surface", "text", "muted", "line", "accent", "on_accent", "good", "warning", "danger"];
+export type ColorKey = (typeof COLOR_KEYS)[number];
+export type Scheme = 'dark' | 'light';
+export type Palette = Record<ColorKey, string>;
+export type Colors = Partial<Palette> & {
+    scheme?: Scheme;
+};
+export declare const SCHEMES: Record<Scheme, Omit<Palette, 'accent' | 'on_accent'>>;
+export declare const SERIES: Record<Scheme, string[]>;
+export declare const HEX: RegExp;
+/** WCAG contrast ratio, from 1 to 21. */
+export declare function contrast(a: string, b: string): number;
+export declare function resolveColors(colors: Colors | undefined, fallbackScheme: Scheme, fallbackAccent: string): Palette;
+/** White or near-black, whichever reads better on a state fill. */
+export declare function inkOn(fill: string): string;
+export declare function contrastWarnings(p: Palette): string[];
+/** Applies the palette as CSS variables, plus the chart series for its scheme. */
+export declare function applyColors(p: Palette, target?: HTMLElement): void;

package/dist/types/components.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from 'preact';
+import type { Alert, Component, Data, GridLayout } from './types';
+export declare function gridStyle(l: GridLayout): Record<string, string>;
+export declare function Screen({ zones, layout, data, alert, }: {
+    zones: Record<string, Component>;
+    layout: GridLayout;
+    data: Data;
+    alert?: Alert;
+}): JSX.Element;
+export declare function Problems({ errors, warnings, }: {
+    errors: string[];
+    warnings: string[];
+}): JSX.Element | null;

package/dist/types/cycle-fit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sizes a cycle to its longest message, so the size never jumps between
+ * messages. One line suits a banner; a tall, narrow zone wraps instead,
+ * whichever lets the text be larger.
+ */
+export declare function fitMessages(el: HTMLElement, messages: string[]): void;

package/dist/types/data.d.ts

@@ -0,0 +1,19 @@
+import type { Data, Value } from './types';
+/** Reads "/menu/0/price" from the data. Missing paths give undefined. */
+export declare function getPath(data: unknown, path: string): unknown;
+export declare function isBind(v: unknown): v is {
+    bind: string;
+    fallback?: string | number;
+};
+/**
+ * Resolves a value to display text. A bind that is missing or empty in the
+ * data shows its `fallback`; without one it resolves to "" and the component
+ * shows its own empty state.
+ */
+export declare function text(v: Value | undefined, data: Data): string;
+/** Resolves a value that should be a list, literal or bound. */
+export declare function items<T>(v: T[] | {
+    bind: string;
+}, data: Data): unknown[];
+/** Deep merge: objects merge key by key, arrays and values are replaced. */
+export declare function merge(base: unknown, over: unknown): unknown;

package/dist/types/empty.d.ts

@@ -0,0 +1,6 @@
+/** Stands in for a missing single value: a stat, a meter, a table cell. */
+export declare const DASH = "\u2014";
+/** Shown instead of an empty list, table, chart or image. */
+export declare function Empty({ text }: {
+    text?: string;
+}): import("preact").JSX.Element;

package/dist/types/fit.d.ts

@@ -0,0 +1,3 @@
+import { fitMessages } from './cycle-fit';
+export { fitMessages };
+export declare function fitAll(root: ParentNode): void;

package/dist/types/flow.d.ts

@@ -0,0 +1,7 @@
+import type { FlowLayout, GridLayout, Layout } from './types';
+export declare const COLUMNS = 12;
+/** Reference canvas: 1080 px on the short side, the long side follows the screen. */
+export declare function canvasSize(viewW: number, viewH: number): [number, number];
+export declare const isFlow: (l: Layout) => l is FlowLayout;
+export declare function flowGrid(l: FlowLayout, width: number): GridLayout;
+export declare function toGrid(l: Layout, width: number): GridLayout;

package/dist/types/icon-paths.d.ts

@@ -0,0 +1,2 @@
+import type { IconName } from './icons';
+export declare const ICONS: Record<IconName, string>;

package/dist/types/icon.d.ts

@@ -0,0 +1,7 @@
+import type { IconName } from './icons';
+export declare function loadIcons(): Promise<Record<string, string>>;
+/** A named icon from the set in icons.ts, drawn in the current text color. */
+export declare function Icon({ name, cls }: {
+    name: IconName;
+    cls?: string;
+}): import("preact").JSX.Element;

package/dist/types/icons.d.ts

@@ -0,0 +1,3 @@
+export declare const ICON_NAMES: readonly ["info", "check", "warning", "danger", "fire", "evacuate", "assembly", "medical", "first-aid", "storm", "wind", "snow", "flood", "heat", "lockdown", "shelter", "security", "power", "water", "network", "closed", "delay", "maintenance", "announcement", "phone", "biohazard", "radiation", "chemical", "event", "location", "accessibility"];
+export type IconName = (typeof ICON_NAMES)[number];
+export declare const isIcon: (v: unknown) => v is IconName;

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+import './style.css';
+export { mount } from './mount';
+export type { MountOptions, ScreenHandle, Update } from './mount';
+export { check } from './check';
+export type { CheckOptions, CheckResult, Source } from './check';
+export { validate } from './validate';
+export type { Result as ValidateResult } from './validate';
+export { canvasSize } from './flow';
+export { COLOR_KEYS, SCHEMES } from './colors';
+export type { ColorKey, Colors, Palette, Scheme } from './colors';
+export { ICON_NAMES } from './icons';
+export type { IconName } from './icons';
+export { LEVELS } from './alert';
+export type { Level } from './alert';
+export type * from './types';
+export { pack, previewUrl, unpack, PREVIEW_BASE } from './share';
+export type { PreviewOptions, Shared } from './share';
+export { FORMAT } from './version';
+export { DEFAULT_SIZES, parseSize, SIZES } from './sizes';
+export type { Size } from './sizes';

package/dist/types/lists.d.ts

@@ -0,0 +1,29 @@
+import { type TimeOptions } from './time';
+import type { Clocks, Data, Queue, Schedule, Status } from './types';
+export declare function StatusView({ c, data }: {
+    c: Status;
+    data: Data;
+}): import("preact").JSX.Element;
+export interface Entry {
+    start: string;
+    title: string;
+    detail: string;
+    tag: 'now' | 'next' | '';
+}
+/**
+ * Entries from the current one onward. An entry ends at its `end`, else when
+ * the next later entry of the same kind starts, else an hour after it starts.
+ */
+export declare function upcoming(raw: unknown[], data: Data, now: Date, limit: number, time?: TimeOptions): Entry[];
+export declare function ScheduleView({ c, data }: {
+    c: Schedule;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function QueueView({ c, data }: {
+    c: Queue;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function ClocksView({ c, data }: {
+    c: Clocks;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/measure.d.ts

@@ -0,0 +1,4 @@
+/** Font size, in px, that components are measured at before scaling. */
+export declare const PROBE = 100;
+/** The box a component fills: its parent, without padding. */
+export declare function contentBox(box: HTMLElement): [number, number];

package/dist/types/measures.d.ts

@@ -0,0 +1,22 @@
+import type { Bars, Data, Meter, Meters, Split } from './types';
+export declare function MeterView({ c, data }: {
+    c: Meter;
+    data: Data;
+}): import("preact").JSX.Element;
+export declare function MetersView({ c, data }: {
+    c: Meters;
+    data: Data;
+}): import("preact").JSX.Element;
+/** Ranked bars, largest first, all against the largest value. */
+export declare function BarsView({ c, data }: {
+    c: Bars;
+    data: Data;
+}): import("preact").JSX.Element;
+/**
+ * One whole split into parts. Each block prints its share when it is wide
+ * enough; the legend repeats name and share, so no value is lost.
+ */
+export declare function SplitView({ c, data }: {
+    c: Split;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/media.d.ts

@@ -0,0 +1,15 @@
+import type { Data, Qr, Slideshow } from './types';
+/** Swaps images instantly on a timer and preloads the next one. */
+export declare function SlideshowView({ c, data }: {
+    c: Slideshow;
+    data: Data;
+}): import("preact").JSX.Element;
+/**
+ * One SVG path for all dark modules, with a four-module quiet zone. Always
+ * black on white: many phone scanners fail on inverted codes.
+ */
+export declare function qrPath(grid: boolean[][]): string;
+export declare function QrView({ c, data }: {
+    c: Qr;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/mount.d.ts

@@ -0,0 +1,45 @@
+import { type Source } from './check';
+import { type Colors, type Scheme } from './colors';
+export interface MountOptions {
+    /** The screen document: JSON or YAML text, or a parsed object. */
+    layout: Source;
+    /** Values that binds read: JSON or YAML text, or an object. */
+    data?: Source;
+    /** Scheme used when the document doesn't set one. Default dark. */
+    scheme?: Scheme;
+    /** Accent used when the document doesn't set one. Default #2563eb. */
+    accent?: string;
+    /**
+     * Colors that win over the document's own, like `{ scheme: 'light' }` to
+     * see a screen in the other scheme.
+     */
+    colors?: Colors;
+    /** IANA time zone for clocks and schedules. Default the device's. */
+    timeZone?: string;
+    /** BCP 47 locale for dates and times. Default the device's. */
+    locale?: string;
+    /** Show errors and warnings over the screen. Default false. */
+    showProblems?: boolean;
+    /** Freezes the clock at this time, for screenshots and tests. */
+    now?: Date;
+}
+export interface Update {
+    layout?: Source;
+    data?: Source;
+}
+export interface ScreenHandle {
+    /** Errors from the last check, plus any reported with report(). */
+    readonly errors: string[];
+    readonly warnings: string[];
+    /** Replaces the layout, the data or both, and renders again. */
+    update(changes: Update): Promise<void>;
+    /** Adds an error, shown over the screen when showProblems is on. */
+    report(message: string): void;
+    /** Stops watching the element's size and removes the screen. */
+    destroy(): void;
+}
+/**
+ * Renders a screen document into `container` and resolves once it is drawn,
+ * charts included. The container sets the size; the screen fills it.
+ */
+export declare function mount(container: HTMLElement, options: MountOptions): Promise<ScreenHandle>;

package/dist/types/parse.d.ts

@@ -0,0 +1,11 @@
+export interface Parsed {
+    value: unknown;
+    error?: string;
+}
+/**
+ * `layout` uses the YAML core schema, so `fit: true` and `gap: 24` keep their
+ * types. `data` uses the failsafe schema, which reads every scalar as a
+ * string: a price written as 4.50 stays "4.50" instead of becoming 4.5.
+ */
+export type Mode = 'layout' | 'data';
+export declare function parseText(src: string, mode: Mode): Promise<Parsed>;

package/dist/types/qr-size.d.ts

@@ -0,0 +1,2 @@
+/** QR codes: the largest square that fits beside their caption. */
+export declare function sizeQr(root: ParentNode): void;

package/dist/types/ready.d.ts

@@ -0,0 +1,3 @@
+export declare function track(p: Promise<unknown>): void;
+/** Resolves when tracked work is done, or after `timeout` ms at the latest. */
+export declare function settled(timeout?: number): Promise<void>;

package/dist/types/share.d.ts

@@ -0,0 +1,33 @@
+export declare const PREVIEW_BASE = "https://signagekit.514sid.com/preview/";
+export interface PreviewOptions {
+    /** `screen` (default), `sizes`, `schemes` or `edit`. */
+    mode?: 'screen' | 'sizes' | 'schemes' | 'edit';
+    /**
+     * Resolution: a name like `fullhd` or `portrait`, or `WIDTHxHEIGHT`. One
+     * for `screen` and `schemes`, a list for `sizes`.
+     */
+    size?: string | string[];
+    scheme?: 'dark' | 'light';
+    accent?: string;
+    timeZone?: string;
+    locale?: string;
+    /** Show errors and warnings over the screen. */
+    problems?: boolean;
+    /** Freeze the clock at this ISO time, like 2026-11-14T09:30. */
+    now?: string;
+    /** Preview page to link to. Default the public site. */
+    base?: string;
+}
+export interface Shared {
+    layout: string;
+    data?: string;
+}
+/** Packs layout and data text into the `s` value of a preview link. */
+export declare function pack(shared: Shared): Promise<string>;
+/** Reverses pack(). Throws on a damaged value. */
+export declare function unpack(s: string): Promise<Shared>;
+/**
+ * A link to the preview page showing this layout and data. Pass the text as
+ * written, JSON or YAML, or objects, which are sent as JSON.
+ */
+export declare function previewUrl(layout: string | object, data?: string | object, options?: PreviewOptions): Promise<string>;

package/dist/types/sizes.d.ts

@@ -0,0 +1,15 @@
+export interface Size {
+    name: string;
+    width: number;
+    height: number;
+    label: string;
+}
+/** Every named resolution, keyed by name. */
+export declare const SIZES: Record<string, Size>;
+/** The sizes the preview compares when none are given. */
+export declare const DEFAULT_SIZES: string[];
+/**
+ * Reads `fullhd`, `1080p` or `1366x768` (also `1366×768`). Returns null for
+ * anything else, or for sizes under 64 or over 16384 px.
+ */
+export declare function parseSize(text: string): Size | null;

package/dist/types/specs.d.ts

@@ -0,0 +1,7 @@
+import { type Check } from './checks';
+import type { ComponentType } from './types';
+export interface Spec {
+    required: Record<string, Check>;
+    optional: Record<string, Check>;
+}
+export declare const SPECS: Record<ComponentType, Spec>;

package/dist/types/stat.d.ts

@@ -0,0 +1,38 @@
+import type { Component, Data, Stat as StatSpec, Thresholds, Value } from './types';
+type Props = {
+    c: StatSpec;
+    data: Data;
+};
+export declare const STATE_WORDS: Record<string, string>;
+/** good, warning or danger; anything else, unknown included, is neutral. */
+export declare function stateText(v: Value | undefined, data: Data): string;
+/**
+ * A state from thresholds: past danger is danger, past warning is warning,
+ * anything else neutral. With danger below warning, lower values are worse.
+ */
+export declare function thresholdState(n: number, t: Thresholds | undefined): string;
+/**
+ * The state that marks a whole zone. Only stats and meters set one: an
+ * explicit `state` wins, else `thresholds` decide from the value.
+ */
+export declare function stateOf(c: Component, data: Data): string;
+export declare function StateIcon({ state }: {
+    state: string;
+}): import("preact").JSX.Element;
+/**
+ * up, down or flat, or none. With good_when set, a move that way is good
+ * (green) and the opposite is bad (red); without it the arrow stays neutral,
+ * since a rising number is not always good news.
+ */
+export declare function trendOf(c: StatSpec, data: Data): {
+    dir: string;
+    tone: string;
+} | null;
+/**
+ * Numbers of 10,000 and up are shortened (1M, 12.9K) unless format is full,
+ * so a big value doesn't shrink every stat in its row. Smaller numbers get
+ * thousands separators; text that isn't a number is shown as written.
+ */
+export declare function formatValue(raw: string, format?: 'compact' | 'full'): string;
+export declare function Stat({ c, data }: Props): import("preact").JSX.Element;
+export {};

package/dist/types/table-fit.d.ts

@@ -0,0 +1,8 @@
+export declare function tableOverflow(el: HTMLElement): void;
+/**
+ * Shows every row a table could show at once, all of them or the first
+ * page_rows, and hides its pager, so fitting and paging measure the same
+ * content on every pass. Returns a function that hands rows back to the
+ * table's own paging.
+ */
+export declare function showAllRows(root: ParentNode): () => void;

package/dist/types/table.d.ts

@@ -0,0 +1,11 @@
+import type { Data, Table as TableSpec } from './types';
+/**
+ * A table that sizes its text to fit. Rows that don't fit at a readable size
+ * are shown a page at a time, flipping instantly; page_rows caps the page
+ * size by hand. Rows off the page are collapsed, not removed, so column widths
+ * stay the same on every page and nothing jumps.
+ */
+export declare function Table({ c, data }: {
+    c: TableSpec;
+    data: Data;
+}): import("preact").JSX.Element;

package/dist/types/time.d.ts

@@ -0,0 +1,28 @@
+type Listener = (now: Date) => void;
+export declare function onMinute(fn: Listener): () => void;
+/**
+ * Time zone, locale and an optional frozen clock for one mounted screen.
+ * Each mount() provides its own, so screens on one page don't share them.
+ */
+export interface TimeOptions {
+    timeZone?: string;
+    locale?: string;
+    /**
+     * A fixed time stops the clock, so screenshots of clocks, schedules and
+     * countdowns come out the same on every run.
+     */
+    now?: Date;
+}
+export declare const TimeContext: import("preact").Context<TimeOptions>;
+export declare const useTimeOptions: () => TimeOptions;
+/** The current time, updated each minute, or the screen's fixed time. */
+export declare function useMinute(): Date;
+/** The time in another zone, for world clocks. */
+export declare function formatClockIn(now: Date, zone: string, hour12: boolean | undefined, t?: TimeOptions): string;
+/** Minutes since midnight on the screen's clock, for "HH:MM" schedules. */
+export declare function minutesOfDay(now: Date, t?: TimeOptions): number;
+export declare function formatClock(now: Date, hour12: boolean | undefined, t?: TimeOptions): string;
+export declare function formatDate(now: Date, t?: TimeOptions): string;
+/** "3 d 4 h", "4 h 12 min", "12 min", or "" once the time has passed. */
+export declare function formatCountdown(to: Date, now: Date): string;
+export {};

package/dist/types/trend-fit.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fits a stat in each arrangement it can take, using `fitLine`, which returns
+ * the size the element fits at as it stands, or less than `floor` by how far
+ * it is from fitting at all. Leaves the best one in place
+ * and remembers every size for the row pass. Returns false when there is
+ * nothing to choose, so the caller fits the stat normally.
+ */
+export declare function fitTrend(el: HTMLElement, fitLine: () => number, floor: number): boolean;
+/**
+ * Picks one arrangement for a row of figures: the one whose smallest size is
+ * largest. A stat that can't take an arrangement keeps its own nearest one.
+ * Returns the size the row shares.
+ */
+export declare function alignTrends(group: HTMLElement[], sizeOf: (el: HTMLElement) => number, floor?: number): number;

package/dist/types/type-scale.d.ts

@@ -0,0 +1,10 @@
+export declare const RANGES: Record<string, [number, number]>;
+/** The type scale every fitted size snaps down to. */
+export declare const STEPS: number[];
+/** Components made of rows; they share one body size across the screen. */
+export declare const BODY: string[];
+/** Display text kept within this many times the body size. */
+export declare const DISPLAY: string[];
+export declare const DISPLAY_RATIO = 3.5;
+/** List-like components may grow this much past the shared body size. */
+export declare const BODY_SPREAD = 1.4;