@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/workloads/stateless/broadcast/client/eventEmitter.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * @module EventEmitter
+ * Implements a simple event emitter pattern for handling custom events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+/**
+ * A simple event emitter class that allows for subscribing to, unsubscribing from,
+ * and emitting custom events.
+ */
+class EventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    /**
+     * Registers a new listener for a specified event.
+     * @param eventName The name of the event to listen for.
+     * @param listener The callback function to be invoked when the event is emitted.
+     */
+    on(eventName, listener) {
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, new Set());
+        }
+        this.listeners.get(eventName)?.add(listener);
+    }
+    /**
+     * Removes a registered listener for a specified event.
+     * @param eventName The name of the event to remove the listener from.
+     * @param listener The callback function to be removed.
+     */
+    off(eventName, listener) {
+        if (this.listeners.has(eventName)) {
+            this.listeners.get(eventName)?.delete(listener);
+        }
+    }
+    /**
+     * Emits an event, invoking all registered listeners for that event.
+     * @param eventName The name of the event to emit.
+     * @param args Any arguments to pass to the listeners.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    emit(eventName, ...args) {
+        if (this.listeners.has(eventName)) {
+            // Create a shallow copy to prevent issues if listeners modify the set during iteration
+            const listenersToCall = Array.from(this.listeners.get(eventName));
+            for (const listener of listenersToCall) {
+                listener(...args);
+            }
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;

package/dist/cjs/workloads/stateless/broadcast/client/messageBuilder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module messageBuilder
+ * Provides utility functions for constructing WebSocket messages
+ * according to the AWS AppSync Events API protocol.
+ */
+/**
+ * Builds a 'subscribe' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the subscription.
+ * @param channel The channel path to subscribe to (e.g., '/my/channel').
+ * @param authorization An object containing the authorization details for the subscription.
+ * @returns A JSON object representing the 'subscribe' message.
+ */
+export declare function buildSubscribeMessage(id: string, channel: string, authorization: object): object;
+/**
+ * Builds a 'publish' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the publish operation.
+ * @param channel The channel path to publish to.
+ * @param events An array of stringified JSON events to be published.
+ * @param authorization An object containing the authorization details for the publish operation.
+ * @returns A JSON object representing the 'publish' message.
+ */
+export declare function buildPublishMessage(id: string, channel: string, events: string[], authorization: object): object;

package/dist/cjs/workloads/stateless/broadcast/client/messageBuilder.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @module messageBuilder
+ * Provides utility functions for constructing WebSocket messages
+ * according to the AWS AppSync Events API protocol.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSubscribeMessage = buildSubscribeMessage;
+exports.buildPublishMessage = buildPublishMessage;
+/**
+ * Builds a 'subscribe' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the subscription.
+ * @param channel The channel path to subscribe to (e.g., '/my/channel').
+ * @param authorization An object containing the authorization details for the subscription.
+ * @returns A JSON object representing the 'subscribe' message.
+ */
+function buildSubscribeMessage(id, channel, authorization) {
+    return {
+        type: "subscribe",
+        id,
+        channel,
+        authorization,
+    };
+}
+/**
+ * Builds a 'publish' message for the AWS AppSync Events API.
+ *
+ * @param id A unique identifier for the publish operation.
+ * @param channel The channel path to publish to.
+ * @param events An array of stringified JSON events to be published.
+ * @param authorization An object containing the authorization details for the publish operation.
+ * @returns A JSON object representing the 'publish' message.
+ */
+function buildPublishMessage(id, channel, events, authorization) {
+    return {
+        type: "publish",
+        id,
+        channel,
+        events,
+        authorization,
+    };
+}

package/dist/cjs/workloads/stateless/broadcast/client/parser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module parser
+ * Provides utility functions for parsing incoming WebSocket messages
+ * from the AWS AppSync Events API.
+ */
+/**
+ * Parses a raw WebSocket message string into a structured JavaScript object.
+ * @param message The raw message string received from the WebSocket.
+ * @returns The parsed message object.
+ * @throws {Error} If the message is not valid JSON.
+ */
+export declare function parseMessage(message: string): object;

package/dist/cjs/workloads/stateless/broadcast/client/parser.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @module parser
+ * Provides utility functions for parsing incoming WebSocket messages
+ * from the AWS AppSync Events API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMessage = parseMessage;
+/**
+ * Parses a raw WebSocket message string into a structured JavaScript object.
+ * @param message The raw message string received from the WebSocket.
+ * @returns The parsed message object.
+ * @throws {Error} If the message is not valid JSON.
+ */
+function parseMessage(message) {
+    try {
+        return JSON.parse(message);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse message: ${message}. Error: ${error}`);
+    }
+}

package/dist/cjs/workloads/stateless/broadcast/client/provider.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+export declare function Broadcast({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/cjs/workloads/stateless/broadcast/client/provider.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broadcast = Broadcast;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const broadcast_provider_js_1 = require("./broadcast-provider.js");
+function Broadcast({ children }) {
+    return ((0, jsx_runtime_1.jsx)(broadcast_provider_js_1.BroadcastContextProvider, { urlAndHost: {
+            url: process.env.ML_BROADCAST_URL ?? "ws://localhost:9311",
+            host: process.env.ML_BROADCAST_HOST ?? "localhost",
+        }, children: children }));
+}

package/dist/cjs/workloads/stateless/broadcast/client/subscriptionManager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module SubscriptionManager
+ * Manages subscriptions to channels in the AWS AppSync Events API.
+ */
+import type { EventEmitter } from "./eventEmitter.js";
+type SubscriberCallback = (data: object) => void;
+/**
+ * Represents a manager for handling subscriptions to various channels.
+ * It interacts with a connection manager to send subscription messages.
+ */
+export declare class SubscriptionManager {
+    private connectionManager;
+    private subscribers;
+    private subscriptionPromises;
+    /**
+     * Creates an instance of SubscriptionManager.
+     * @param connectionManager The connection manager responsible for sending messages.
+     */
+    constructor(connectionManager: any, eventEmitter: EventEmitter);
+    /**
+     * Subscribes to a specified channel.
+     * @param channel The channel path to subscribe to.
+     * @param authorization The authorization object for the subscription.
+     * @param callback The callback function to invoke when data is received for this subscription.
+     * @returns The ID of the created subscription.
+     */
+    subscribe(channel: string, authorization: object, callback: SubscriberCallback): string;
+    /**
+     * Unsubscribes from a previously subscribed channel.
+     * @param subscriptionId The ID of the subscription to unsubscribe from.
+     */
+    unsubscribe(subscriptionId: string): void;
+}
+export {};

package/dist/cjs/workloads/stateless/broadcast/client/subscriptionManager.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * @module SubscriptionManager
+ * Manages subscriptions to channels in the AWS AppSync Events API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionManager = void 0;
+const uuid_1 = require("uuid");
+const messageBuilder_js_1 = require("./messageBuilder.js");
+/**
+ * Represents a manager for handling subscriptions to various channels.
+ * It interacts with a connection manager to send subscription messages.
+ */
+class SubscriptionManager {
+    /**
+     * Creates an instance of SubscriptionManager.
+     * @param connectionManager The connection manager responsible for sending messages.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(connectionManager, eventEmitter) {
+        this.connectionManager = connectionManager;
+        this.subscribers = new Map();
+        this.subscriptionPromises = new Map();
+        // Register a handler for incoming messages from the ConnectionManager
+        eventEmitter.on("message", (message) => {
+            switch (message.type) {
+                case "data":
+                    console.log("data", message);
+                    if (this.subscribers.get(message.id)) {
+                        // Event content is a stringified JSON, so parse it
+                        this.subscribers.get(message.id)(JSON.parse(message.event));
+                    }
+                    break;
+                case "subscribe_success":
+                    if (this.subscriptionPromises.get(message.id)) {
+                        this.subscriptionPromises.get(message.id).resolve();
+                        this.subscriptionPromises.delete(message.id);
+                    }
+                    break;
+                case "subscribe_error":
+                    if (this.subscriptionPromises.get(message.id)) {
+                        this.subscriptionPromises
+                            .get(message.id)
+                            .reject(new Error(message.errors[0]?.message || "Subscription error"));
+                        this.subscriptionPromises.delete(message.id);
+                    }
+                    break;
+            }
+        });
+    }
+    /**
+     * Subscribes to a specified channel.
+     * @param channel The channel path to subscribe to.
+     * @param authorization The authorization object for the subscription.
+     * @param callback The callback function to invoke when data is received for this subscription.
+     * @returns The ID of the created subscription.
+     */
+    subscribe(channel, authorization, callback) {
+        // Changed return type to string
+        const id = (0, uuid_1.v4)();
+        const subscribeMessage = (0, messageBuilder_js_1.buildSubscribeMessage)(id, channel, authorization);
+        this.connectionManager.send(JSON.stringify(subscribeMessage));
+        this.subscribers.set(id, callback);
+        // Store the resolve/reject functions for this subscription ID
+        let resolvePromise;
+        let rejectPromise;
+        const promise = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        this.subscriptionPromises.set(id, {
+            resolve: resolvePromise,
+            reject: rejectPromise,
+            promise,
+        });
+        return id; // Return the id immediately
+    }
+    /**
+     * Unsubscribes from a previously subscribed channel.
+     * @param subscriptionId The ID of the subscription to unsubscribe from.
+     */
+    unsubscribe(subscriptionId) {
+        const unsubscribeMessage = {
+            type: "unsubscribe",
+            id: subscriptionId,
+        };
+        this.connectionManager.send(JSON.stringify(unsubscribeMessage));
+        this.subscribers.delete(subscriptionId);
+    }
+}
+exports.SubscriptionManager = SubscriptionManager;

package/dist/cjs/workloads/stateless/broadcast/client/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @module types
+ * Defines TypeScript interfaces for the AWS AppSync Events WebSocket protocol messages.
+ */
+/**
+ * Base interface for all AppSync WebSocket messages.
+ */
+export interface AppSyncMessage {
+    type: string;
+}
+/**
+ * Interface for the 'connection_ack' message.
+ */
+export interface ConnectionAckMessage extends AppSyncMessage {
+    type: "connection_ack";
+    connectionTimeoutMs: number;
+}
+/**
+ * Interface for the 'ka' (keep-alive) message.
+ */
+export interface KaMessage extends AppSyncMessage {
+    type: "ka";
+}
+/**
+ * Interface for 'subscribe_success' message.
+ */
+export interface SubscribeSuccessMessage extends AppSyncMessage {
+    type: "subscribe_success";
+    id: string;
+}
+/**
+ * Interface for 'subscribe_error' message.
+ */
+export interface SubscribeErrorMessage extends AppSyncMessage {
+    type: "subscribe_error";
+    id: string;
+    errors: any[];
+}
+/**
+ * Interface for 'data' message.
+ */
+export interface DataMessage extends AppSyncMessage {
+    type: "data";
+    id: string;
+    event: string;
+}
+/**
+ * Interface for 'broadcast_error' message.
+ */
+export interface BroadcastErrorMessage extends AppSyncMessage {
+    type: "broadcast_error";
+    id: string;
+    errors: any[];
+}
+/**
+ * Interface for 'publish_success' message.
+ */
+export interface PublishSuccessMessage extends AppSyncMessage {
+    type: "publish_success";
+    id: string;
+    successful: any[];
+    failed: any[];
+}
+/**
+ * Interface for 'publish_error' message.
+ */
+export interface PublishErrorMessage extends AppSyncMessage {
+    type: "publish_error";
+    id: string;
+    errors: any[];
+}
+export type AppSyncWebSocketMessage = ConnectionAckMessage | KaMessage | SubscribeSuccessMessage | SubscribeErrorMessage | DataMessage | BroadcastErrorMessage | PublishSuccessMessage | PublishErrorMessage;

package/dist/cjs/workloads/stateless/broadcast/client/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @module types
+ * Defines TypeScript interfaces for the AWS AppSync Events WebSocket protocol messages.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/workloads/stateless/broadcast/matcher.d.ts

@@ -0,0 +1,13 @@
+type RouteParams = {
+    [key: string]: string;
+};
+export declare class RouteMatcher {
+    private routes;
+    constructor(routes: string[]);
+    private buildRegex;
+    match(url: string): {
+        route: string;
+        params: RouteParams;
+    } | null;
+}
+export {};

package/dist/cjs/workloads/stateless/broadcast/matcher.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteMatcher = void 0;
+class RouteMatcher {
+    constructor(routes) {
+        this.routes = routes;
+    }
+    buildRegex(route) {
+        // Escape static segments and convert dynamic segments (e.g., [id]) into capture groups
+        const pattern = route
+            .split("/")
+            .map((segment) => {
+            if (segment.startsWith("[") && segment.endsWith("]")) {
+                // Capture dynamic segment as a parameter
+                return "([^/]+)";
+            }
+            // Escape static segments
+            return segment.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+        })
+            .join("/");
+        return new RegExp(`^${pattern}$`);
+    }
+    match(url) {
+        for (const route of this.routes) {
+            const regex = this.buildRegex(route);
+            const match = url.match(regex);
+            if (match) {
+                // Extract dynamic parameters from the match
+                const params = {};
+                const segments = route
+                    .split("/")
+                    .filter((segment) => segment.startsWith("[") && segment.endsWith("]"));
+                const values = match.slice(1);
+                segments.forEach((segment, index) => {
+                    const paramName = segment.slice(1, -1); // Remove the square brackets
+                    if (values[index]) {
+                        params[paramName] = values[index];
+                    }
+                });
+                return { route, params };
+            }
+        }
+        return null; // No match found
+    }
+}
+exports.RouteMatcher = RouteMatcher;

package/dist/cjs/workloads/stateless/broadcast/router.d.ts

@@ -0,0 +1,103 @@
+import { Workload } from "../../../workloads/workload.js";
+import type { RouteParams } from "./types.js";
+export type IsValidSegment<S extends string> = S extends `${infer _Start}[${infer Param}]${infer After}` ? After extends `/${string}` | "" ? IsValidSegment<After> : false : true;
+export type ValidateRouteFormat<T extends string> = IsValidSegment<T> extends true ? T : never;
+export type ExtractRouteParamsTuple<T extends string, Acc extends string[] = []> = T extends `${string}[${infer Param}]${infer Rest}` ? ExtractRouteParamsTuple<Rest, [...Acc, Param]> : Acc;
+export type HasDuplicates<T extends readonly any[]> = T extends [
+    infer F,
+    ...infer R
+] ? F extends R[number] ? true : HasDuplicates<R> : false;
+export type ValidateUniqueParams<T extends string> = HasDuplicates<ExtractRouteParamsTuple<T>> extends true ? never : T;
+export type ValidateRoute<T extends string> = ValidateRouteFormat<T> extends never ? never : ValidateUniqueParams<T> extends never ? never : T;
+export type ValidateRoutes<T extends Record<string, any>> = {
+    [K in keyof T]: ValidateRoute<K & string> extends never ? never : T[K];
+};
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type Simplify<T> = DrainOuterGeneric<{
+    [K in keyof T]: T[K];
+} & {}>;
+/**
+ * Creates a Broadcast workloads
+ *
+ * The constructore takes a session handler and a configuration object for channels. Each channel
+ * is mapped to a path and an optional authorization handler. The channel paths can
+ * include dynamic segments, like `/users/[id]`, which are parsed and passed to the
+ * authorization logic.
+ *
+ * @template T - A record mapping channel strings to their channel data types.
+ * @template S - The type of the session object, returned by the `session` function.
+ *
+ * @param session A function that resolves to a session object. This object is available
+ *   within the authorization handlers. It receives an object with `cookies` as an argument.
+ * @param channels An object where keys are route strings and values are objects defining
+ *   the channel and its authorization logic.
+ *   - `auth`: An optional function to authorize "PUBLISH" or "SUBSCRIBE" operations.
+ *     It receives the operation type, route parameters, and the session object.
+ *   - `channel`: The channel instance for the route.
+ *
+ * @returns An object containing the configured channels, an internal authorization function (`authFn`),
+ *   and the session handler.
+ *
+ * @example
+ * ```ts
+ * import { channel, Broadcast } from "@monolayer/sdk";
+ *
+ * const broadcast = new Broadcast(
+ *   async () => ({ userId: 1 }),
+ *   {
+ *     "/todos": {
+ *       channel: channel<{ message: string }>(),
+ *       auth: async (ctx) => {
+ *         console.log("User trying to access todos:", ctx.session.userId);
+ *         return true; // Allow access
+ *       },
+ *     },
+ *     "/users/[id]": {
+ *       channel: channel<{ salute: string }>(),
+ *       auth: async (ctx) => {
+ *         // Only allow users to access their own channel
+ *         return ctx.session.userId === Number(ctx.params.id);
+ *       },
+ *     },
+ *   }
+ * );
+ *
+ * export default broadcast;
+ * ```
+ */
+export declare class Broadcast<T extends Record<string, any>, S> extends Workload {
+    session: (opts: {
+        cookies: Record<string, string>;
+    }) => Promise<S>;
+    channels: {
+        [channel in keyof T]: ValidateRoute<channel & string> extends never ? never : {
+            auth?: (ctx: {
+                operation: "PUBLISH" | "SUBSCRIBE";
+                params: channel extends string ? Simplify<RouteParams<channel>> : never;
+                session: S;
+            }) => Promise<boolean>;
+            data: T[channel];
+        };
+    };
+    _channelDataType: {
+        [K in keyof T]: T[K];
+    };
+    constructor(initOpts: {
+        session?: (opts: {
+            cookies: Record<string, string>;
+        }) => Promise<S>;
+        channels: {
+            [channel in keyof T]: ValidateRoute<channel & string> extends never ? never : {
+                auth?: (ctx: {
+                    operation: "PUBLISH" | "SUBSCRIBE";
+                    params: channel extends string ? Simplify<RouteParams<channel>> : never;
+                    session: S;
+                }) => Promise<boolean>;
+                data: T[channel];
+            };
+        };
+    });
+    authFn(route: string, operation: "PUBLISH" | "SUBSCRIBE", session: S): Promise<boolean>;
+    get connectionStringEnvVar(): "ML_BROADCAST_URL";
+}
+export type AnyBroadcast = Broadcast<any, any>;

package/dist/cjs/workloads/stateless/broadcast/router.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broadcast = void 0;
+const path_1 = __importDefault(require("path"));
+const workload_js_1 = require("../../../workloads/workload.js");
+const matcher_js_1 = require("./matcher.js");
+/**
+ * Creates a Broadcast workloads
+ *
+ * The constructore takes a session handler and a configuration object for channels. Each channel
+ * is mapped to a path and an optional authorization handler. The channel paths can
+ * include dynamic segments, like `/users/[id]`, which are parsed and passed to the
+ * authorization logic.
+ *
+ * @template T - A record mapping channel strings to their channel data types.
+ * @template S - The type of the session object, returned by the `session` function.
+ *
+ * @param session A function that resolves to a session object. This object is available
+ *   within the authorization handlers. It receives an object with `cookies` as an argument.
+ * @param channels An object where keys are route strings and values are objects defining
+ *   the channel and its authorization logic.
+ *   - `auth`: An optional function to authorize "PUBLISH" or "SUBSCRIBE" operations.
+ *     It receives the operation type, route parameters, and the session object.
+ *   - `channel`: The channel instance for the route.
+ *
+ * @returns An object containing the configured channels, an internal authorization function (`authFn`),
+ *   and the session handler.
+ *
+ * @example
+ * ```ts
+ * import { channel, Broadcast } from "@monolayer/sdk";
+ *
+ * const broadcast = new Broadcast(
+ *   async () => ({ userId: 1 }),
+ *   {
+ *     "/todos": {
+ *       channel: channel<{ message: string }>(),
+ *       auth: async (ctx) => {
+ *         console.log("User trying to access todos:", ctx.session.userId);
+ *         return true; // Allow access
+ *       },
+ *     },
+ *     "/users/[id]": {
+ *       channel: channel<{ salute: string }>(),
+ *       auth: async (ctx) => {
+ *         // Only allow users to access their own channel
+ *         return ctx.session.userId === Number(ctx.params.id);
+ *       },
+ *     },
+ *   }
+ * );
+ *
+ * export default broadcast;
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class Broadcast extends workload_js_1.Workload {
+    constructor(initOpts) {
+        super("broadcast");
+        this.session =
+            initOpts.session ??
+                (async () => {
+                    return {};
+                });
+        this.channels = initOpts.channels;
+    }
+    async authFn(route, operation, session) {
+        const auth = {};
+        for (const routeName of Object.keys(this.channels)) {
+            if (this.channels[routeName]) {
+                auth[`${path_1.default.join("default", routeName)}`] =
+                    this.channels[routeName].auth;
+            }
+        }
+        const matcher = new matcher_js_1.RouteMatcher(Object.keys(this.channels).map((r) => path_1.default.join("default", r)));
+        const match = matcher.match(route);
+        if (match) {
+            const routeAuth = auth[route];
+            if (routeAuth === undefined)
+                return true;
+            return await routeAuth({
+                session: session,
+                params: match.params,
+                operation,
+            });
+        }
+        else {
+            return true;
+        }
+    }
+    get connectionStringEnvVar() {
+        return "ML_BROADCAST_URL";
+    }
+}
+exports.Broadcast = Broadcast;

package/dist/cjs/workloads/stateless/broadcast/types.d.ts

@@ -0,0 +1,17 @@
+export type Channel<T> = {
+    _data: T;
+    subscribed?: (ctx: any) => void;
+    unsubscribed?: (ctx: any) => void;
+};
+export type ChannelData<T extends Channel<any>> = T extends Channel<infer D> ? D : never;
+export type Channels = Record<string, Channel<any>>;
+export type ExtractRouteParamsTuple<T extends string, Acc extends string[] = []> = T extends `${string}[${infer Param}]${infer Rest}` ? ExtractRouteParamsTuple<Rest, [...Acc, Param]> : Acc;
+export type HasDuplicates<T extends readonly any[]> = T extends [
+    infer F,
+    ...infer R
+] ? F extends R[number] ? true : HasDuplicates<R> : false;
+export type ValidateUniqueParams<T extends string> = HasDuplicates<ExtractRouteParamsTuple<T>> extends true ? ["❌ Duplicate route params not allowed in", T] : T;
+export type TupleToParamObject<T extends readonly string[]> = {
+    [K in T[number]]: string;
+};
+export type RouteParams<T extends string> = TupleToParamObject<ExtractRouteParamsTuple<T>>;

package/dist/cjs/workloads/stateless/broadcast/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });