@roku-sdk/rsg-ts 0.0.0-stage → 2.19.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roku, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,12 @@
-# Temporary Holding Version
+# @roku-sdk/rsg-ts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Core SDK package for building Roku SceneGraph applications with TypeScript. Re-exports APIs from internal packages (`@roku-sdk/native`, `@roku-sdk/ts-core`) so that application code only needs to depend on `@roku-sdk/rsg-ts`.
+
+## DCL module registry
+
+`@roku-sdk/rsg-ts/module-registry` is an opt-in side-effect import for apps that host TypeScript DCLs. It publishes the SDK barrels on `globalThis.__ROKU_MODULES__` so a DCL's `require()` calls resolve. The main entry point no longer imports it, so ordinary apps tree-shake the runtime APIs they do not use. See [DCL: host app entry point](../../documentation/core-concepts/dcl.md#opting-in-to-the-module-registry).
+
+## Documentation
+
+- [Exception Handling](../../documentation/runtime-and-debugging/exception-handling.md) — Forward uncaught exceptions to monitoring services
+- [Full SDK Documentation](../../documentation/README.md)

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@roku-sdk/rsg-ts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.19.0",
+  "description": "Roku SceneGraph TypeScript Components",
+  "type": "module",
+  "sideEffects": [
+    "./src/module-registry.ts"
+  ],
+  "main": "./src/main.ts",
+  "exports": {
+    ".": "./src/main.ts",
+    "./tsconfig.json": "./tsconfig.json",
+    "./tsconfig.base.json": "./tsconfig/tsconfig.base.json",
+    "./roku-config": "./roku-config.ts",
+    "./runtime": "./src/runtime.ts",
+    "./interfaces": "./src/interfaces.ts",
+    "./dcl": "./src/dcl.ts",
+    "./module-registry": "./src/module-registry.ts"
+  },
+  "engines": {
+    "npm": ">=8.5.0",
+    "node": ">=24.0.0"
+  },
+  "files": [
+    "src/",
+    "tsconfig/",
+    "tsconfig.json",
+    "tsconfig.base.json",
+    "roku-config.ts"
+  ],
+  "compilerOptions": {
+    "target": "es2020"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.4.1",
+    "@roku-sdk/dev-tools": "2.19.0",
+    "@roku-sdk/testing-library": "2.19.0"
+  },
+  "author": "Roku Inc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/rokudev/rsg-sdk.git",
+    "directory": "packages/rsg-ts"
+  },
+  "homepage": "https://gitlab.com/rokudev/rsg-sdk/-/tree/main/packages/rsg-ts#readme",
+  "bugs": {
+    "url": "https://gitlab.com/rokudev/rsg-sdk/-/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@roku-sdk/components": "2.19.0",
+    "@roku-sdk/common": "2.19.0",
+    "@roku-sdk/runtime": "2.19.0",
+    "@roku-sdk/native": "2.19.0",
+    "@roku-sdk/interfaces": "2.19.0",
+    "@roku-sdk/sdk-config": "2.19.0",
+    "@roku-sdk/solid": "2.19.0",
+    "@roku-sdk/ts-core": "2.19.0"
+  },
+  "scripts": {
+    "rk": "rk",
+    "test": "jest",
+    "coverage": "jest --coverage --runInBand --passWithNoTests --testTimeout=60000 --forceExit",
+    "clean": "rm -rf dist",
+    "lint": "eslint --no-error-on-unmatched-pattern \"src/**/*.{ts,tsx,mjs,cjs,js}\""
+  }
 }

package/roku-config.ts

@@ -0,0 +1,57 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+import type { SdkConfig as InternalRokuConfig, UserSdkConfig as RokuConfig } from "@roku-sdk/sdk-config";
+
+export type { RokuConfig, InternalRokuConfig };
+
+// Pipeline extension types — re-exported here so consumers have a single
+// canonical import path (`@roku-sdk/rsg-ts/roku-config`) for everything
+// needed to type `roku-config.ts`, including lifecycle hooks and plugin slots.
+export type {
+    RokuPipeline,
+    BuildPipeline,
+    StartDevPipeline,
+    BuildHookContext,
+    PostBuildHookContext,
+    DeployHookContext,
+    DeployHookDevice,
+    ManifestEntries,
+    PipelinePlugin,
+    BuildPluginSlot,
+    StartDevPluginSlot,
+    PositionFor
+} from "@roku-sdk/sdk-config";
+
+/** Minimal Node process.env ambient so consumers without `@types/node` can typecheck this helper. */
+declare const process: { env: Record<string, string | undefined> };
+
+/**
+ * Get the current build type from the environment
+ * @returns The `--build-type` value, or the command's default when none is given: `"production"`
+ * for `rk build`, `"development"` for `rk dev`. `"unknown"` when the config is loaded outside `rk`.
+ * @description This function can be called within roku-config.ts to conditionally configure
+ * manifest entries or other settings based on the build type. Build types can be specified
+ * via command line: `npx rk build --build-type staging` or `npx rk dev --build-type staging`
+ *
+ * @example
+ * ```typescript
+ * import type { RokuConfig } from "@roku-sdk/rsg-ts/roku-config";
+ * import { getBuildType } from "@roku-sdk/rsg-ts/roku-config";
+ *
+ * const buildType = getBuildType();
+ *
+ * const configuration: RokuConfig = {
+ *     app: {
+ *         entryPoint: "src/index.ts",
+ *         manifestEntries: {
+ *             title: buildType === "production" ? "My App" : `My App (${buildType})`,
+ *             hidden: buildType === "development" ? 1 : 0,
+ *         }
+ *     }
+ * };
+ * ```
+ */
+export const getBuildType = (): string => {
+    return process.env.ROKU_BUILD_TYPE || "unknown";
+};

package/src/dcl.ts

@@ -0,0 +1,77 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+import { Component, JSX } from "@roku-sdk/solid";
+
+/**
+ * Retrieves a TS DCL component from the global registry and returns it as a SolidJS-compatible
+ * component function that can be used directly in JSX.
+ *
+ * This is the recommended way to render TS DCL components inside a TypeScript host app.
+ * Since both host and DCL are TypeScript, no firmware communication is required — the DCL
+ * component is composed directly into the host's render tree as a plain SolidJS function.
+ *
+ * Call this after `LoadStatus.READY` has fired for the given library.
+ *
+ * @param libraryName - The DCL library name (matches the library provided by the DCL app)
+ * @param componentName - The component name as declared in its descriptor
+ * @returns A SolidJS `Component` function suitable for JSX usage
+ *
+ * @throws {Error} If the library or component is not found in the global registry
+ *
+ * @example
+ * ```typescript
+ * import { getDCLComponent } from "@roku-sdk/rsg-ts";
+ *
+ * // Inside LoadStatus.READY handler:
+ * const Cowboy = getDCLComponent("tsDCL", "Cowboy");
+ * setCowboyComponent(() => Cowboy);
+ *
+ * // In JSX:
+ * <Show when={CowboyComponent()}>{(Comp) => <Comp />}</Show>
+ * ```
+ */
+export function getDCLComponent<P extends Record<string, unknown> = Record<string, unknown>>(
+    libraryName: string,
+    componentName: string
+): Component<P> {
+    const registry = (
+        globalThis as typeof globalThis & {
+            __LOADED_DCL_COMPONENTS?: Record<
+                string,
+                Array<{
+                    description: {
+                        componentName: string;
+                        extends: string;
+                        inputFields: Record<string, unknown>;
+                        outputFields: Record<string, unknown>;
+                        libraryName?: string;
+                    };
+                    component: (inputs: unknown, outputs: unknown) => unknown;
+                }>
+            >;
+        }
+    ).__LOADED_DCL_COMPONENTS;
+    if (!registry || !registry[libraryName]) {
+        throw new Error(
+            `DCL library "${libraryName}" not found. Make sure getDCLComponent is called after LoadStatus.READY.`
+        );
+    }
+
+    const libraryComponents = registry[libraryName];
+    const entry = libraryComponents.find(
+        (componentEntry: { description: { componentName: string } }) =>
+            componentEntry.description.componentName === componentName
+    );
+    if (!entry) {
+        throw new Error(`Component "${componentName}" not found in DCL library "${libraryName}".`);
+    }
+
+    const noopOutputs: Record<string, () => void> = {};
+    for (const key of Object.keys(entry.description.outputFields)) {
+        noopOutputs[key] = () => {};
+    }
+
+    const { component } = entry;
+    return (props: P) => component(props, noopOutputs) as unknown as JSX.Element;
+}

package/src/interfaces.ts

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+export * from "@roku-sdk/interfaces";

package/src/main.ts

@@ -0,0 +1,19 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+export { logger } from "@roku-sdk/common";
+export {
+    declareTsComponent, //Deprecated: use declareAnchorNode instead
+    defineAnchorNode,
+    registerAnchorNode,
+    FieldType
+} from "@roku-sdk/ts-core";
+export type {
+    TsComponent, //Deprecated: Use AnchorNodeImplementation instead
+    TsComponentDeclaration, //Deprecated: Use AnchorNodeDescriptor instead
+    AnchorNodeDescriptor,
+    AnchorNodeImplementation
+} from "@roku-sdk/ts-core";
+export { main, enableExceptionTagging, setUncaughtExceptionHandler } from "@roku-sdk/native";
+export { useDelay } from "./use-delay";
+export { getDCLComponent } from "./dcl";

package/src/module-registry.ts

@@ -0,0 +1,40 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+import * as rsgTs from "@roku-sdk/rsg-ts";
+import * as interfaces from "@roku-sdk/rsg-ts/interfaces";
+import * as runtime from "@roku-sdk/rsg-ts/runtime";
+import * as solid from "@roku-sdk/solid";
+
+// Extend globalThis type to include Roku module registry
+declare global {
+    var __ROKU_MODULES__: Record<string, unknown>;
+    var require: (moduleName: string) => unknown;
+}
+
+// Framework provides SDK modules via global registry for DCL require() calls
+// No exports needed - DCLs use globalThis.require() instead
+// Register framework exports in global namespace for DCL require() calls
+// Create global module registry
+globalThis.__ROKU_MODULES__ = globalThis.__ROKU_MODULES__ || {};
+Object.assign(globalThis.__ROKU_MODULES__, {
+    "@roku-sdk/rsg-ts/interfaces": interfaces,
+    "@roku-sdk/rsg-ts": rsgTs,
+    "@roku-sdk/solid": solid,
+    "@roku-sdk/rsg-ts/runtime": runtime
+});
+
+// Provide global require function for DCLs
+globalThis.require = function (moduleName: string) {
+    const modules = globalThis.__ROKU_MODULES__;
+    if (modules && modules[moduleName]) {
+        return modules[moduleName];
+    }
+    // Hermes CDP inspector probes require("module") during debug session setup
+    // to detect CommonJS environments. Silently return undefined for this probe
+    // so it doesn't trigger "break on all exceptions" in the debugger.
+    if (moduleName === "module") {
+        return undefined;
+    }
+    throw new Error(`Module not found: ${moduleName}`);
+};

package/src/runtime.ts

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+export { getRegistry } from "@roku-sdk/runtime/registry";
+export { useLaunchConfig } from "@roku-sdk/runtime/launch-config";
+export { getAppInfo } from "@roku-sdk/runtime/app-info";
+export { useCec, useCEC } from "@roku-sdk/runtime/cec";
+export { getHdmiStatus, useHdmiStatus } from "@roku-sdk/runtime/hdmi-status";
+export type { HdmiStatus } from "@roku-sdk/runtime/hdmi-status";
+export { getAppMemoryMonitor, useAppMemoryMonitor } from "@roku-sdk/runtime/app-memory-monitor";
+export type { AppMemoryMonitor } from "@roku-sdk/runtime/app-memory-monitor";
+export { getDeviceInfo } from "@roku-sdk/runtime/device-info";
+export { hasFeature } from "@roku-sdk/runtime/has-feature";
+export type { DeviceInfoStatic } from "@roku-sdk/runtime/device-info";
+export { useDeviceInfoEvents, useUiResolution } from "@roku-sdk/runtime/device-info-events";
+/** @deprecated Use useUiResolution instead */
+export { useUIResolution } from "@roku-sdk/runtime/device-info-events";
+export type { DeviceInfoEventsHook, UIResolution } from "@roku-sdk/runtime/device-info-events";
+export { useInput } from "@roku-sdk/runtime/input";
+export type { InputEventsHook } from "@roku-sdk/runtime/input";
+export { useLifecycle } from "@roku-sdk/runtime/lifecycle";
+export { getFileSystem, useFileSystem } from "@roku-sdk/runtime/file-system";
+export { crypto } from "@roku-sdk/runtime/crypto";
+export { getFontMeasure, whenFontReady, createFontReady } from "@roku-sdk/runtime/font";
+export type { FontReadyAbortSignal, WhenFontReadyOptions } from "@roku-sdk/runtime/font";
+export type { LifecycleEventsHook } from "@roku-sdk/runtime/lifecycle";
+export { getAudioGuide } from "@roku-sdk/runtime/audio-guide";
+export { getTextToSpeech } from "@roku-sdk/runtime/text-to-speech";
+export { getVoiceDictation, useVoiceDictation } from "@roku-sdk/runtime/voice-dictation";
+export type { VoiceDictationHook } from "@roku-sdk/runtime/voice-dictation";
+export { useVoiceCommands } from "@roku-sdk/runtime/voice-commands";
+export type { VoiceCommandHook } from "@roku-sdk/runtime/voice-commands";
+export { DictationEvent, DictationKeyboardType } from "@roku-sdk/interfaces";
+export type { DictationInputParams, VoiceDictation } from "@roku-sdk/interfaces";
+export { getPerfetto } from "@roku-sdk/runtime/perfetto";

package/src/types/sg-jsx.d.ts

@@ -0,0 +1,188 @@
+// Auto-generated. DO NOT EDIT.
+// Source: ../components/src/sg-intrinsics.json — run `pnpm generate:sg-intrinsics` in @roku-sdk/components to regenerate.
+//
+// `export {}` makes this a TypeScript MODULE file (not a script), enabling proper
+// module augmentation. Without it, `declare module` creates a standalone ambient
+// namespace that shadows JSX.ElementChildrenAttribute from solid-js, breaking
+// automatic `children` handling in <Show>, <For>, <ErrorBoundary>, etc.
+export {};
+
+import type {
+    IAnimatedImageProps,
+    IAnimationBaseProps,
+    IAnimationProps,
+    IAudioProps,
+    IBifDisplayProps,
+    IBlendedBusySpinnerProps,
+    IBoundingTrackerProps,
+    IBusySpinnerProps,
+    IButtonGroupProps,
+    IButtonProps,
+    IChannelStoreProps,
+    ICheckListProps,
+    IColorFieldInterpolatorProps,
+    IContentNodeProps,
+    IDialogProps,
+    IDynamicKeyboardProps,
+    IDynamicKeyGridProps,
+    IDynamicMiniKeyboardProps,
+    IDynamicPinPadProps,
+    IEffectProps,
+    IFloatFieldInterpolatorProps,
+    IFocusableGroupProps,
+    IFocusableProps,
+    IFontProps,
+    IFullPanelProps,
+    IGroupProps,
+    IKeyboardPropsWithVoice,
+    IKeyHandlerProps,
+    ILabelListProps,
+    ILabelProps,
+    ILayoutGroupProps,
+    IListPanelProps,
+    IMarkupGridProps,
+    IMarkupListProps,
+    IMaskGroupProps,
+    IModalProps,
+    IMultiStyleLabelProps,
+    IOverhangProps,
+    IPanelProps,
+    IPanelSetProps,
+    IPosterGridProps,
+    IPosterProps,
+    IProgressBarProps,
+    IRadioButtonListProps,
+    IRectangleProps,
+    IRowListProps,
+    ISceneProps,
+    IScrollableTextProps,
+    IScrollingLabelProps,
+    ISimpleLabelProps,
+    ISoundEffectProps,
+    IStandardDialogProps,
+    IStandardDialogRSGPaletteNodeProps,
+    IStandardKeyboardDialogProps,
+    IStandardMessageDialogProps,
+    IStandardPinPadDialogProps,
+    IStandardProgressDialogProps,
+    IStdDlgActionCardItemProps,
+    IStdDlgBulletTextItemProps,
+    IStdDlgButtonAreaProps,
+    IStdDlgButtonProps,
+    IStdDlgContentAreaProps,
+    IStdDlgCustomItemProps,
+    IStdDlgDeterminateProgressItemProps,
+    IStdDlgGraphicItemProps,
+    IStdDlgItemGroupProps,
+    IStdDlgKeyboardItemProps,
+    IStdDlgMultiStyleTextItemProps,
+    IStdDlgProgressItemProps,
+    IStdDlgSideCardAreaProps,
+    IStdDlgTextItemProps,
+    IStdDlgTitleAreaProps,
+    ITargetGroupProps,
+    ITargetListProps,
+    ITargetSetProps,
+    ITimeGridProps,
+    ITrickPlayBarProps,
+    ITweenProps,
+    IVector2DFieldInterpolatorProps,
+    IVideoProps,
+    IVoiceTextEditBoxProps,
+    IZoomRowListProps
+} from "@roku-sdk/components/jsx-props";
+
+declare module "@roku-sdk/solid/jsx-runtime" {
+    namespace JSX {
+        interface IntrinsicElements {
+            checkList: ICheckListProps;
+            labelList: ILabelListProps;
+            markupList: IMarkupListProps;
+            maskGroup: IMaskGroupProps;
+            label: ILabelProps;
+            scrollingLabel: IScrollingLabelProps;
+            scrollableText: IScrollableTextProps;
+            simpleLabel: ISimpleLabelProps;
+            multiStyleLabel: IMultiStyleLabelProps;
+            button: IButtonProps;
+            buttonGroup: IButtonGroupProps;
+            busySpinner: IBusySpinnerProps;
+            blendedBusySpinner: IBlendedBusySpinnerProps;
+            group: IGroupProps;
+            "key-handler": IKeyHandlerProps;
+            animatedImage: IAnimatedImageProps;
+            poster: IPosterProps;
+            overhang: IOverhangProps;
+            animation: IAnimationProps;
+            sequentialAnimation: IAnimationBaseProps;
+            floatFieldInterpolator: IFloatFieldInterpolatorProps;
+            colorFieldInterpolator: IColorFieldInterpolatorProps;
+            vector2dFieldInterpolator: IVector2DFieldInterpolatorProps;
+            rectangle: IRectangleProps;
+            rowList: IRowListProps;
+            timeGrid: ITimeGridProps;
+            zoomRowList: IZoomRowListProps;
+            scene: ISceneProps;
+            layoutGroup: ILayoutGroupProps;
+            managedListPanel: IListPanelProps;
+            listPanel: IFullPanelProps;
+            panelSet: IPanelSetProps;
+            panel: IPanelProps;
+            radioButtonList: IRadioButtonListProps;
+            modal: IModalProps;
+            "modal-dialog": IModalProps;
+            standardDialogExt: IStandardDialogProps;
+            standardDialog: IStandardDialogProps;
+            standardKeyboardDialogExt: IStandardKeyboardDialogProps;
+            standardMessageDialogExt: IStandardMessageDialogProps;
+            standardPinPadDialogExt: IStandardPinPadDialogProps;
+            standardProgressDialogExt: IStandardProgressDialogProps;
+            dialog: IDialogProps;
+            stdDlgTitleArea: IStdDlgTitleAreaProps;
+            stdDlgContentArea: IStdDlgContentAreaProps;
+            stdDlgButtonArea: IStdDlgButtonAreaProps;
+            stdDlgSideCardArea: IStdDlgSideCardAreaProps;
+            stdDlgButton: IStdDlgButtonProps;
+            stdDlgItemGroup: IStdDlgItemGroupProps;
+            stdDlgActionCardItem: IStdDlgActionCardItemProps;
+            stdDlgBulletTextItem: IStdDlgBulletTextItemProps;
+            stdDlgDeterminateProgressItem: IStdDlgDeterminateProgressItemProps;
+            stdDlgGraphicItem: IStdDlgGraphicItemProps;
+            stdDlgMultiStyleTextItem: IStdDlgMultiStyleTextItemProps;
+            stdDlgKeyboardItem: IStdDlgKeyboardItemProps;
+            stdDlgProgressItem: IStdDlgProgressItemProps;
+            stdDlgTextItem: IStdDlgTextItemProps;
+            stdDlgCustomItem: IStdDlgCustomItemProps;
+            contentNode: IContentNodeProps;
+            posterGrid: IPosterGridProps;
+            markupGrid: IMarkupGridProps;
+            video: IVideoProps;
+            bifDisplay: IBifDisplayProps;
+            trickPlayBar: ITrickPlayBarProps;
+            progressBar: IProgressBarProps;
+            "bounding-tracker": IBoundingTrackerProps;
+            "focusable-group": IFocusableGroupProps;
+            focusable: IFocusableProps;
+            font: IFontProps;
+            channelStoreExt: IChannelStoreProps;
+            audio: IAudioProps;
+            soundEffect: ISoundEffectProps;
+            rsgPalette: IStandardDialogRSGPaletteNodeProps;
+            effect: IEffectProps;
+            targetGroup: ITargetGroupProps;
+            targetList: ITargetListProps;
+            targetSet: ITargetSetProps;
+            customKeyboard: IKeyboardPropsWithVoice;
+            dynamicKeyGrid: IDynamicKeyGridProps;
+            keyGridExt: IDynamicKeyGridProps;
+            dynamicKeyboard: IDynamicKeyboardProps;
+            keyboardExt: IDynamicKeyboardProps;
+            dynamicMiniKeyboard: IDynamicMiniKeyboardProps;
+            miniKeyboardExt: IDynamicMiniKeyboardProps;
+            dynamicPinPad: IDynamicPinPadProps;
+            pinPadExt: IDynamicPinPadProps;
+            voiceTextEditBox: IVoiceTextEditBoxProps;
+            tween: ITweenProps;
+        }
+    }
+}

package/src/types/xml.d.ts

@@ -0,0 +1,4 @@
+declare module "*.xml" {
+    const componentName: string;
+    export default componentName;
+}

package/src/use-delay.ts

@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+// These helpers map the type of timeoutId to a number
+const setTimeout = (handler: (...args: unknown[]) => void, timeout?: number, ...args: unknown[]): number => {
+    return globalThis.setTimeout(handler, timeout, ...args) as unknown as number;
+};
+const clearTimeout = (handle: number): void => {
+    globalThis.clearTimeout(handle);
+};
+
+/**
+ * A custom hook that provides a delay function and a mechanism to resolve all pending delays early.
+ *
+ * @returns {[ (ms: number) => Promise<void>, () => void ]}
+ * - `delay(ms: number): Promise<void>`: A function that returns a promise which resolves after the specified delay in milliseconds.
+ * - `resolveDelaysEarly(): void`: A function that resolves all pending delay promises immediately and clears their timeouts.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * const [delay, resolveDelaysEarly] = useDelay();
+ *
+ * // Using the delay function
+ * await delay(1000); // Waits for 1 second
+ *
+ * // Resolving delays early
+ * const promise = delay(5000); // Starts a 5-second delay
+ * resolveDelaysEarly(); // Resolves the promise immediately
+ * await promise; // The promise resolves without waiting for 5 seconds
+ * ```
+ *
+ * This hook is useful for scenarios where you need to manage delays but also require the ability
+ * to cancel or resolve them early, such as in testing or cleanup operations.
+ */
+
+export const useDelay = (): [
+    (ms: number) => Promise<void>, // delay function
+    () => void // resolveDelaysEarly function
+] => {
+    const timeouts = new Map<number, () => void>(); // Map to track timeouts and their resolve functions
+
+    const delay = (ms: number): Promise<void> => {
+        return new Promise(resolve => {
+            const timeoutId = setTimeout(() => {
+                resolve();
+                timeouts.delete(timeoutId); // Cleanup after the timeout finishes
+            }, ms);
+
+            // Store the timeout ID and resolve function
+            timeouts.set(timeoutId, resolve);
+        });
+    };
+
+    const resolveDelaysEarly = () => {
+        for (const [timeoutId, resolve] of timeouts) {
+            clearTimeout(timeoutId); // Clear all timeouts
+            resolve(); // Resolve all pending promises early
+        }
+        timeouts.clear(); // Clear the map after resolving
+    };
+
+    return [delay, resolveDelaysEarly];
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "@roku-sdk/dev-tools/typescript-config/tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "types": ["@roku-sdk/interfaces/global", "@roku-sdk/components/jsx"]
+    },
+    "include": ["src/**/*"],
+    "files": ["src/types/xml.d.ts", "src/types/sg-jsx.d.ts"]
+}