lib-maestro-dmx 1.0.0

package/dist/control.js

@@ -0,0 +1,259 @@
+import { oscFloat, OscClient } from "./osc.js";
+function assertLiveGroup(group) {
+    if (!Number.isInteger(group) || group < 1 || group > 4) {
+        throw new RangeError("Live group must be an integer between 1 and 4.");
+    }
+}
+function assertUnitInterval(name, value) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new RangeError(`${name} must be a finite number between 0 and 1.`);
+    }
+}
+function assertInteger(name, value, minimum = 0) {
+    if (!Number.isInteger(value) || value < minimum) {
+        throw new RangeError(`${name} must be an integer greater than or equal to ${minimum}.`);
+    }
+}
+function assertString(name, value) {
+    if (value.trim().length === 0) {
+        throw new RangeError(`${name} must not be empty.`);
+    }
+}
+class GlobalControlApi {
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+    }
+    async setBrightness(value) {
+        assertUnitInterval("Global brightness", value);
+        await this.oscClient.sendThrottled("/global/brightness", { intervalMs: 300 }, oscFloat(value));
+    }
+}
+class AudioControlApi {
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+    }
+    async setInput(name) {
+        assertString("Audio input name", name);
+        await this.oscClient.send("/audio/input", name);
+    }
+    async nextInput() {
+        await this.oscClient.send("/audio/input/next");
+    }
+}
+class LiveControlApi {
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+    }
+    async pause() {
+        await this.oscClient.send("/live/pause");
+    }
+    async resume() {
+        await this.oscClient.send("/live/resume");
+    }
+    async stop() {
+        await this.oscClient.send("/live/stop");
+    }
+}
+class LiveGroupControlApi {
+    oscClient;
+    group;
+    constructor(oscClient, group) {
+        assertLiveGroup(group);
+        this.oscClient = oscClient;
+        this.group = group;
+    }
+    async setPattern(name) {
+        assertString("Pattern name", name);
+        await this.oscClient.send(this.address("pattern"), name);
+    }
+    async setPatternIndex(index) {
+        assertInteger("Pattern index", index);
+        await this.oscClient.send(this.address("pattern/index"), index);
+    }
+    async setPalette(id) {
+        assertInteger("Palette id", id);
+        await this.oscClient.send(this.address("palette"), id);
+    }
+    async setPaletteIndex(index) {
+        assertInteger("Palette index", index);
+        await this.oscClient.send(this.address("palette/index"), index);
+    }
+    async setFxPaletteIndex(index) {
+        assertInteger("FX palette index", index);
+        await this.oscClient.send(this.address("fx/index"), index);
+    }
+    async setBrightness(value) {
+        assertUnitInterval("Brightness", value);
+        await this.oscClient.sendThrottled(this.address("brightness"), { intervalMs: 500 }, oscFloat(value));
+    }
+    async setExcitement(value) {
+        assertUnitInterval("Excitement", value);
+        await this.oscClient.sendThrottled(this.address("excitement"), oscFloat(value));
+    }
+    async setBackground(value) {
+        assertUnitInterval("Background", value);
+        await this.oscClient.sendThrottled(this.address("background"), oscFloat(value));
+    }
+    async setMotionRange(value) {
+        assertUnitInterval("Motion range", value);
+        await this.oscClient.sendThrottled(this.address("motion/range"), oscFloat(value));
+    }
+    async setMotionSpeed(value) {
+        assertUnitInterval("Motion speed", value);
+        await this.oscClient.sendThrottled(this.address("motion/speed"), oscFloat(value));
+    }
+    async setSpeed(value) {
+        assertUnitInterval("Speed", value);
+        await this.oscClient.sendThrottled(this.address("speed"), oscFloat(value));
+    }
+    async setEnergy(value) {
+        assertUnitInterval("Energy", value);
+        await this.oscClient.sendThrottled(this.address("energy"), oscFloat(value));
+    }
+    async setVariance(value) {
+        assertUnitInterval("Variance", value);
+        await this.oscClient.sendThrottled(this.address("variance"), oscFloat(value));
+    }
+    async setDecay(value) {
+        assertUnitInterval("Decay", value);
+        await this.oscClient.sendThrottled(this.address("decay"), oscFloat(value));
+    }
+    async setAttack(value) {
+        assertUnitInterval("Attack", value);
+        await this.oscClient.sendThrottled(this.address("attack"), oscFloat(value));
+    }
+    async setShape(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 15) {
+            throw new RangeError("Shape must be an integer between 0 and 15.");
+        }
+        await this.oscClient.send(this.address("shape"), value);
+    }
+    address(suffix) {
+        return `/live/${this.group}/${suffix}`;
+    }
+}
+class ShowControlApi {
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+    }
+    async loadByName(name) {
+        assertString("Show name", name);
+        await this.oscClient.send("/show/name", name);
+    }
+    async next() {
+        await this.oscClient.send("/show/next");
+    }
+    async previous() {
+        await this.oscClient.send("/show/previous");
+    }
+    async loadByIndex(index) {
+        assertInteger("Show index", index);
+        await this.oscClient.send("/show/index", index);
+    }
+    async loadCueByIndex(index) {
+        assertInteger("Cue index", index, 1);
+        await this.oscClient.send("/show/cue/index", index);
+    }
+    async nextCue() {
+        await this.oscClient.send("/show/cue/next");
+    }
+    async previousCue() {
+        await this.oscClient.send("/show/cue/previous");
+    }
+    async playPause() {
+        await this.oscClient.send("/show/play_pause");
+    }
+    async play() {
+        await this.oscClient.send("/show/play");
+    }
+    async stop() {
+        await this.oscClient.send("/show/stop");
+    }
+}
+class TriggerControlApi {
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+    }
+    async setStrobe(enabled) {
+        await this.oscClient.send("/triggers/strobe", enabled);
+    }
+    async toggleStrobe() {
+        await this.oscClient.send("/triggers/strobe/toggle");
+    }
+    async setStrobeBrightness(value) {
+        assertUnitInterval("Strobe brightness", value);
+        await this.oscClient.send("/triggers/strobe/brightness", oscFloat(value));
+    }
+    async setStrobeRate(value) {
+        assertUnitInterval("Strobe rate", value);
+        await this.oscClient.send("/triggers/strobe/rate", oscFloat(value));
+    }
+    async setBlinder(enabled) {
+        await this.oscClient.send("/triggers/blinder", enabled);
+    }
+    async toggleBlinder() {
+        await this.oscClient.send("/triggers/blinder/toggle");
+    }
+    async setBlinderBrightness(value) {
+        assertUnitInterval("Blinder brightness", value);
+        await this.oscClient.send("/triggers/blinder/brightness", oscFloat(value));
+    }
+    async setBlackout(enabled) {
+        await this.oscClient.send("/triggers/blackout", enabled);
+    }
+    async toggleBlackout() {
+        await this.oscClient.send("/triggers/blackout/toggle");
+    }
+    async setFog(enabled) {
+        await this.oscClient.send("/triggers/fog", enabled);
+    }
+    async toggleFog() {
+        await this.oscClient.send("/triggers/fog/toggle");
+    }
+    async setFogInterval(value) {
+        assertUnitInterval("Fog interval", value);
+        await this.oscClient.send("/triggers/fog/interval", oscFloat(value));
+    }
+    async setFogDuration(value) {
+        assertUnitInterval("Fog duration", value);
+        await this.oscClient.send("/triggers/fog/duration", oscFloat(value));
+    }
+    async setFogVolume(value) {
+        assertUnitInterval("Fog volume", value);
+        await this.oscClient.send("/triggers/fog/volume", oscFloat(value));
+    }
+    async setFogSpeed(value) {
+        assertUnitInterval("Fog speed", value);
+        await this.oscClient.send("/triggers/fog/speed", oscFloat(value));
+    }
+    async setEffect(enabled) {
+        await this.oscClient.send("/triggers/effect", enabled);
+    }
+    async toggleEffect() {
+        await this.oscClient.send("/triggers/effect/toggle");
+    }
+}
+export class MaestroOscControlApiImpl {
+    global;
+    audio;
+    live;
+    show;
+    triggers;
+    oscClient;
+    constructor(oscClient) {
+        this.oscClient = oscClient;
+        this.global = new GlobalControlApi(oscClient);
+        this.audio = new AudioControlApi(oscClient);
+        this.live = new LiveControlApi(oscClient);
+        this.show = new ShowControlApi(oscClient);
+        this.triggers = new TriggerControlApi(oscClient);
+    }
+    group(group) {
+        return new LiveGroupControlApi(this.oscClient, group);
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,10 @@
+export interface HttpClientOptions {
+    host: string;
+    protocol?: "http" | "https";
+}
+export declare class HttpClient {
+    private readonly host;
+    private readonly protocol;
+    constructor(options: HttpClientOptions);
+    getJson<T>(path: string): Promise<T>;
+}

package/dist/http.js

@@ -0,0 +1,46 @@
+import http from "node:http";
+import https from "node:https";
+export class HttpClient {
+    host;
+    protocol;
+    constructor(options) {
+        this.host = options.host;
+        this.protocol = options.protocol ?? "http";
+    }
+    async getJson(path) {
+        const transport = this.protocol === "https" ? https : http;
+        return new Promise((resolve, reject) => {
+            const request = transport.get({
+                host: this.host,
+                path,
+                headers: {
+                    Accept: "application/json"
+                }
+            }, (response) => {
+                if (!response.statusCode) {
+                    reject(new Error(`HTTP request to "${path}" returned no status code.`));
+                    return;
+                }
+                if (response.statusCode < 200 || response.statusCode >= 300) {
+                    response.resume();
+                    reject(new Error(`HTTP request to "${path}" failed with status ${response.statusCode}.`));
+                    return;
+                }
+                const chunks = [];
+                response.on("data", (chunk) => {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                response.on("end", () => {
+                    try {
+                        const body = Buffer.concat(chunks).toString("utf8");
+                        resolve(JSON.parse(body));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            request.on("error", reject);
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import { BrightnessApi } from "./read/brightness.js";
+import { ColorPalettesApi } from "./read/color-palettes.js";
+import { FixtureGroupsApi } from "./read/fixture-groups.js";
+import { FxPalettesApi } from "./read/fx-palettes.js";
+import type { MaestroOscControlApi } from "./control/osc-control.js";
+import { LiveApi } from "./read/live.js";
+import { PaletteAssignmentsApi } from "./read/palette-assignments.js";
+import { PatternsApi } from "./read/patterns.js";
+import { PatternsAvailableApi } from "./read/patterns-available.js";
+import { MaestroLookupApi } from "./read/lookup.js";
+import { OscClient } from "./transport/osc.js";
+import { ShowApi } from "./read/show.js";
+import { ShowStateApi } from "./read/show-state.js";
+import { SystemInfoApi } from "./read/system-info.js";
+export type { LiveGroup, MaestroOscControlApi } from "./control/osc-control.js";
+export type { LiveSlotState, LiveState } from "./read/live.js";
+export type { BrightnessState } from "./read/brightness.js";
+export type { ColorPalette, ColorPalettesState, PaletteColor } from "./read/color-palettes.js";
+export type { FixtureGroup, FixtureGroupsState } from "./read/fixture-groups.js";
+export type { FxPalette, FxPalettesState } from "./read/fx-palettes.js";
+export type { PaletteAssignment, PaletteAssignmentsState } from "./read/palette-assignments.js";
+export type { PatternDefinition, PatternManifest, PatternParameter, PatternsState } from "./read/patterns.js";
+export type { PatternsAvailableState } from "./read/patterns-available.js";
+export type { CueGroupContext, CurrentCueGroupContext, LiveGroupContext } from "./read/lookup.js";
+export type { ShowCue, ShowState } from "./read/show.js";
+export type { ShowPlaybackState } from "./read/show-state.js";
+export type { ParamGroup, SlotState } from "./read/shared.js";
+export type { SystemInfoState } from "./read/system-info.js";
+export type { HttpClientOptions } from "./transport/http.js";
+export type { OscArgument, OscClientOptions, OscMessage, OscResponse } from "./transport/osc.js";
+export { BrightnessApi } from "./read/brightness.js";
+export { ColorPalettesApi } from "./read/color-palettes.js";
+export { FixtureGroupsApi } from "./read/fixture-groups.js";
+export { FxPalettesApi } from "./read/fx-palettes.js";
+export { MaestroOscControlApiImpl } from "./control/osc-control.js";
+export { LiveApi } from "./read/live.js";
+export { MaestroLookupApi } from "./read/lookup.js";
+export { PaletteAssignmentsApi } from "./read/palette-assignments.js";
+export { PatternsApi } from "./read/patterns.js";
+export { PatternsAvailableApi } from "./read/patterns-available.js";
+export { ShowApi } from "./read/show.js";
+export { ShowStateApi } from "./read/show-state.js";
+export { SystemInfoApi } from "./read/system-info.js";
+export { HttpClient } from "./transport/http.js";
+export { OscClient, decodeOscMessage, encodeOscMessage, oscFloat } from "./transport/osc.js";
+/**
+ * Connection options for creating a MaestroDMX client.
+ */
+export interface MaestroDmxClientOptions {
+    /** Hostname or IP address of the MaestroDMX device. */
+    host: string;
+    /** HTTP protocol used for Web API reads. Defaults to `http`. */
+    protocol?: "http" | "https";
+    /** Optional local UDP port to bind the OSC socket to. */
+    localOscPort?: number;
+}
+/**
+ * Main high-level client for MaestroDMX.
+ *
+ * It combines OSC writes, typed Web API readers, and snapshot-based lookup
+ * helpers for common show-automation workflows.
+ */
+export interface MaestroDmxClient {
+    /** Hostname or IP address of the connected MaestroDMX device. */
+    host: string;
+    /** Low-level OSC transport for raw OSC access. */
+    osc: OscClient;
+    /** Typed MaestroDMX OSC control surface. */
+    control: MaestroOscControlApi;
+    /** Device and software metadata reader. */
+    systemInfo: SystemInfoApi;
+    /** Global stage brightness reader. */
+    brightness: BrightnessApi;
+    /** Current live state reader for all four fixture groups. */
+    live: LiveApi;
+    /** Full pattern catalog reader. */
+    patterns: PatternsApi;
+    /** Flattened list of available pattern ids. */
+    patternsAvailable: PatternsAvailableApi;
+    /** Active palette assignments per fixture group. */
+    paletteAssignments: PaletteAssignmentsApi;
+    /** Color palette catalog reader. */
+    colorPalettes: ColorPalettesApi;
+    /** FX palette / snapshot catalog reader. */
+    fxPalettes: FxPalettesApi;
+    /** Loaded show definition reader. */
+    show: ShowApi;
+    /** Runtime show playback-state reader. */
+    showState: ShowStateApi;
+    /** Fixture-group topology reader. */
+    fixtureGroups: FixtureGroupsApi;
+    /** High-level snapshot resolver across multiple readers. */
+    lookup: MaestroLookupApi;
+    /** Closes the underlying OSC socket and related timers. */
+    close(): Promise<void>;
+}
+/** Creates a fully wired MaestroDMX client instance. */
+export declare function createClient(options: MaestroDmxClientOptions): MaestroDmxClient;

package/dist/index.js

@@ -0,0 +1,90 @@
+import { BrightnessApi } from "./read/brightness.js";
+import { ColorPalettesApi } from "./read/color-palettes.js";
+import { FixtureGroupsApi } from "./read/fixture-groups.js";
+import { FxPalettesApi } from "./read/fx-palettes.js";
+import { MaestroOscControlApiImpl } from "./control/osc-control.js";
+import { LiveApi } from "./read/live.js";
+import { PaletteAssignmentsApi } from "./read/palette-assignments.js";
+import { PatternsApi } from "./read/patterns.js";
+import { PatternsAvailableApi } from "./read/patterns-available.js";
+import { MaestroLookupApi } from "./read/lookup.js";
+import { HttpClient } from "./transport/http.js";
+import { OscClient } from "./transport/osc.js";
+import { ShowApi } from "./read/show.js";
+import { ShowStateApi } from "./read/show-state.js";
+import { SystemInfoApi } from "./read/system-info.js";
+const DEFAULT_OSC_PORT = 7672;
+export { BrightnessApi } from "./read/brightness.js";
+export { ColorPalettesApi } from "./read/color-palettes.js";
+export { FixtureGroupsApi } from "./read/fixture-groups.js";
+export { FxPalettesApi } from "./read/fx-palettes.js";
+export { MaestroOscControlApiImpl } from "./control/osc-control.js";
+export { LiveApi } from "./read/live.js";
+export { MaestroLookupApi } from "./read/lookup.js";
+export { PaletteAssignmentsApi } from "./read/palette-assignments.js";
+export { PatternsApi } from "./read/patterns.js";
+export { PatternsAvailableApi } from "./read/patterns-available.js";
+export { ShowApi } from "./read/show.js";
+export { ShowStateApi } from "./read/show-state.js";
+export { SystemInfoApi } from "./read/system-info.js";
+export { HttpClient } from "./transport/http.js";
+export { OscClient, decodeOscMessage, encodeOscMessage, oscFloat } from "./transport/osc.js";
+class MaestroDmxClientImpl {
+    host;
+    osc;
+    control;
+    systemInfo;
+    brightness;
+    live;
+    patterns;
+    patternsAvailable;
+    paletteAssignments;
+    colorPalettes;
+    fxPalettes;
+    show;
+    showState;
+    fixtureGroups;
+    lookup;
+    constructor(options) {
+        this.host = options.host;
+        this.osc = new OscClient({
+            host: options.host,
+            port: DEFAULT_OSC_PORT,
+            localPort: options.localOscPort
+        });
+        this.control = new MaestroOscControlApiImpl(this.osc);
+        const httpClient = new HttpClient({
+            host: options.host,
+            protocol: options.protocol
+        });
+        this.systemInfo = new SystemInfoApi(httpClient);
+        this.brightness = new BrightnessApi(httpClient);
+        this.live = new LiveApi(httpClient);
+        this.patterns = new PatternsApi(httpClient);
+        this.patternsAvailable = new PatternsAvailableApi(httpClient);
+        this.paletteAssignments = new PaletteAssignmentsApi(httpClient);
+        this.colorPalettes = new ColorPalettesApi(httpClient);
+        this.fxPalettes = new FxPalettesApi(httpClient);
+        this.show = new ShowApi(httpClient);
+        this.showState = new ShowStateApi(httpClient);
+        this.fixtureGroups = new FixtureGroupsApi(httpClient);
+        this.lookup = new MaestroLookupApi({
+            live: this.live,
+            patterns: this.patterns,
+            patternsAvailable: this.patternsAvailable,
+            paletteAssignments: this.paletteAssignments,
+            colorPalettes: this.colorPalettes,
+            fxPalettes: this.fxPalettes,
+            show: this.show,
+            showState: this.showState,
+            fixtureGroups: this.fixtureGroups
+        });
+    }
+    async close() {
+        await this.osc.close();
+    }
+}
+/** Creates a fully wired MaestroDMX client instance. */
+export function createClient(options) {
+    return new MaestroDmxClientImpl(options);
+}

package/dist/internal/normalize.d.ts

@@ -0,0 +1,10 @@
+/** Returns `true` when the input is a non-null object that is not an array. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Normalizes a value to an optional string. */
+export declare function toOptionalString(value: unknown): string | undefined;
+/** Normalizes a value to an optional finite number. */
+export declare function toOptionalNumber(value: unknown): number | undefined;
+/** Normalizes a value to an optional boolean. */
+export declare function toOptionalBoolean(value: unknown): boolean | undefined;
+/** Normalizes an unknown value to an array of validated entries. */
+export declare function normalizeArray<T>(value: unknown, normalizeEntry: (entry: unknown) => T | undefined): T[];

package/dist/internal/normalize.js

@@ -0,0 +1,25 @@
+/** Returns `true` when the input is a non-null object that is not an array. */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Normalizes a value to an optional string. */
+export function toOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Normalizes a value to an optional finite number. */
+export function toOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Normalizes a value to an optional boolean. */
+export function toOptionalBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+/** Normalizes an unknown value to an array of validated entries. */
+export function normalizeArray(value, normalizeEntry) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => normalizeEntry(entry))
+        .filter((entry) => entry !== undefined);
+}

package/dist/live.d.ts

@@ -0,0 +1,42 @@
+import { HttpClient } from "./http.js";
+import { ReadApi } from "./read-api.js";
+export interface LiveSlotState {
+    patternId?: string;
+    paletteId?: string;
+    brightness?: number;
+    excitement?: number;
+    background?: number;
+    intensity?: number;
+    motion?: number;
+    speed?: number;
+    energy?: number;
+    variance?: number;
+    attack?: number;
+    decay?: number;
+    motionSpeed?: number;
+    blackout?: boolean;
+    blackoutOnSilence?: boolean;
+}
+export interface LiveState {
+    mode: string;
+    transition: Record<string, unknown>;
+    primary: LiveSlotState;
+    secondary: LiveSlotState;
+    tertiary: LiveSlotState;
+    quaternary: LiveSlotState;
+    fetchedAt: Date;
+}
+interface LiveApiResponse {
+    type?: unknown;
+    transition?: unknown;
+    params?: unknown;
+    secondaryParams?: unknown;
+    tertiaryParams?: unknown;
+    quaternaryParams?: unknown;
+}
+export declare class LiveApi extends ReadApi<LiveState, LiveApiResponse> {
+    constructor(httpClient: HttpClient);
+    protected getPath(): string;
+    protected normalizeResponse(response: LiveApiResponse, fetchedAt: Date): LiveState;
+}
+export {};

package/dist/live.js

@@ -0,0 +1,44 @@
+import { HttpClient } from "./http.js";
+import { isRecord, toOptionalBoolean, toOptionalNumber, toOptionalString } from "./normalize.js";
+import { ReadApi } from "./read-api.js";
+function normalizeSlotState(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return {
+        patternId: toOptionalString(value.patternId),
+        paletteId: toOptionalString(value.paletteId),
+        brightness: toOptionalNumber(value.brightness),
+        excitement: toOptionalNumber(value.excitement) ?? toOptionalNumber(value.intensity),
+        background: toOptionalNumber(value.background),
+        intensity: toOptionalNumber(value.intensity),
+        motion: toOptionalNumber(value.motion),
+        speed: toOptionalNumber(value.speed),
+        energy: toOptionalNumber(value.energy),
+        variance: toOptionalNumber(value.variance),
+        attack: toOptionalNumber(value.attack),
+        decay: toOptionalNumber(value.decay),
+        motionSpeed: toOptionalNumber(value.motionSpeed),
+        blackout: toOptionalBoolean(value.blackout),
+        blackoutOnSilence: toOptionalBoolean(value.blackoutOnSilence)
+    };
+}
+export class LiveApi extends ReadApi {
+    constructor(httpClient) {
+        super(httpClient);
+    }
+    getPath() {
+        return "/api/v1/live";
+    }
+    normalizeResponse(response, fetchedAt) {
+        return {
+            mode: typeof response.type === "string" ? response.type : "UNKNOWN",
+            transition: isRecord(response.transition) ? response.transition : {},
+            primary: normalizeSlotState(response.params),
+            secondary: normalizeSlotState(response.secondaryParams),
+            tertiary: normalizeSlotState(response.tertiaryParams),
+            quaternary: normalizeSlotState(response.quaternaryParams),
+            fetchedAt
+        };
+    }
+}

package/dist/normalize.d.ts

@@ -0,0 +1,5 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function toOptionalString(value: unknown): string | undefined;
+export declare function toOptionalNumber(value: unknown): number | undefined;
+export declare function toOptionalBoolean(value: unknown): boolean | undefined;
+export declare function normalizeArray<T>(value: unknown, normalizeEntry: (entry: unknown) => T | undefined): T[];

package/dist/normalize.js

@@ -0,0 +1,20 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function toOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function toOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function toOptionalBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+export function normalizeArray(value, normalizeEntry) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => normalizeEntry(entry))
+        .filter((entry) => entry !== undefined);
+}