@tstdl/base 0.93.139 → 0.93.141

package/browser/README.md

@@ -0,0 +1,401 @@
+# Browser Module
+
+A high-level, controller-based wrapper for Playwright, designed to simplify web automation, scraping, and testing tasks within a dependency-injection-friendly architecture.
+
+## Table of Contents
+
+- [Features](#-features)
+- [Core Concepts](#core-concepts)
+- [🚀 Basic Usage](#-basic-usage)
+- [🔧 Advanced Topics](#-advanced-topics)
+  - [Global Configuration](#global-configuration)
+  - [Persistent Contexts](#persistent-contexts)
+  - [Element Interaction & Filtering](#element-interaction--filtering)
+  - [PDF Rendering](#pdf-rendering)
+  - [Logging & Debugging](#logging--debugging)
+  - [Smart Scrolling](#smart-scrolling)
+  - [Frame & Popup Handling](#frame--popup-handling)
+  - [Element Lifecycle & Existence](#element-lifecycle--existence)
+- [📚 API](#-api)
+
+## ✨ Features
+
+- **Hierarchical Controllers:** Encapsulates Playwright entities (`Browser`, `Page`, `Locator`) into managed controllers (`BrowserController`, `PageController`, `ElementController`) for a clean, object-oriented API.
+- **Dependency Injection Ready:** Designed to be resolved and managed by the `@tstdl/base/injector`, simplifying lifecycle and dependency management.
+- **Unified Element API:** `ElementController` provides a consistent interface over Playwright's `Locator` and `ElementHandle`, supporting chaining and advanced filtering.
+- **Pop-up & Frame Handling:** Seamlessly handle multiple tabs and `<iframe>` elements with dedicated controllers and automatic tracking.
+- **Enhanced Capabilities:** Built-in helpers for PDF generation (buffer and stream), smart scrolling, and automatic logger attachment.
+- **Robust Resource Management:** Implements `AsyncDisposable` for reliable cleanup of browsers and contexts.
+
+## Core Concepts
+
+The module is built around a hierarchy of controllers. Each controller wraps a specific part of the browser automation lifecycle:
+
+1.  **`BrowserService`**: The singleton entry point. It manages the creation and lifecycle of `BrowserController` instances.
+2.  **`BrowserController`**: Represents a browser process (e.g., Chromium). It creates isolated `BrowserContextController` sessions.
+3.  **`BrowserContextController`**: Represents an isolated session (incognito-like) with its own cookies and storage. It creates `PageController` tabs.
+4.  **`PageController`**: Represents a single tab. It provides methods for navigation, evaluation, and finding elements.
+5.  **`ElementController`**: Represents a DOM element (via Locator or Handle). It provides methods for interaction (click, type, etc.) and inspection.
+
+## 🚀 Basic Usage
+
+Here is a typical workflow: launching a browser, navigating to a page, interacting with elements, and cleaning up.
+
+```typescript
+import { BrowserService } from '@tstdl/base/browser';
+import { inject } from '@tstdl/base/injector';
+
+// Typically resolved via dependency injection in your application
+const browserService = inject(BrowserService);
+
+// Launch a new browser instance (Chromium by default)
+const browser = await browserService.newBrowser({ headless: false });
+
+try {
+  // Create a new isolated context and a page
+  const context = await browser.newContext();
+  const page = await context.newPage();
+
+  // Navigate to a website
+  await page.navigate('https://playwright.dev/');
+
+  // Locate an element using accessibility roles
+  const getStartedLink = page.getByRole('link', { name: 'Get started' });
+
+  // Interact with the element
+  await getStartedLink.click();
+
+  // Wait for navigation or URL change
+  await page.waitForUrl('**/docs/intro');
+  console.log('Current URL:', page.url());
+
+  // Find elements by text
+  const title = page.getByText('Installation');
+
+  if (await title.isVisible()) {
+    console.log('Installation guide loaded.');
+  }
+} finally {
+  // Closes the browser and all associated contexts/pages
+  await browser.close();
+}
+```
+
+## 🔧 Advanced Topics
+
+### Global Configuration
+
+You can configure default options for all browsers launched by the `BrowserService`. This is typically done during application bootstrap.
+
+```typescript
+import { configureBrowser } from '@tstdl/base/browser';
+import { chromium } from 'playwright';
+
+configureBrowser({
+  // Optionally provide specific browser binaries
+  browsers: { chromium },
+  options: {
+    defaultNewBrowserOptions: {
+      browser: 'chromium',
+      headless: 'new',
+      windowSize: { width: 1920, height: 1080 },
+      defaultNewContextOptions: {
+        locale: 'en-US',
+        colorScheme: 'dark',
+        viewport: { width: 1920, height: 1080 },
+      },
+    },
+  },
+});
+```
+
+### Persistent Contexts
+
+Persistent contexts store session data (cookies, local storage) on disk, allowing you to maintain login states across restarts.
+
+```typescript
+import { BrowserService } from '@tstdl/base/browser';
+import { inject } from '@tstdl/base/injector';
+
+const browserService = inject(BrowserService);
+
+// Data will be saved to './user-data'
+const context = await browserService.newPersistentContext('./user-data', {
+  headless: false,
+});
+
+const page = await context.newPage();
+await page.navigate('https://github.com/login');
+
+// ... perform login manually or automatically ...
+
+// Close the context to save state
+await context.close();
+
+// Next time you run this, the session will be restored
+```
+
+### Element Interaction & Filtering
+
+The `ElementController` supports advanced filtering and chaining to precisely target elements.
+
+```typescript
+import type { PageController } from '@tstdl/base/browser';
+
+async function selectProduct(page: PageController, productName: string) {
+  // Find a list item that contains the specific product name
+  const productCard = page.getByRole('listitem').filter({ hasText: productName });
+
+  // Within that card, find the "Add to Cart" button
+  const addButton = productCard.locate(page.getByRole('button', { name: 'Add to Cart' }));
+
+  if (await addButton.isEnabled()) {
+    await addButton.click();
+  }
+}
+```
+
+### PDF Rendering
+
+`PageController` includes a convenient method to render the current page as a PDF.
+
+```typescript
+import { writeFile } from 'node:fs/promises';
+import type { PageController } from '@tstdl/base/browser';
+
+async function saveAsPdf(page: PageController) {
+  await page.navigate('https://example.com/report');
+
+  const pdfBuffer = await page.renderPdf({
+    format: 'A4',
+    printBackground: true,
+    margin: { top: '1cm', bottom: '1cm', left: '1cm', right: '1cm' },
+    displayHeaderFooter: true,
+    footerTemplate: '<div style="font-size: 10px; text-align: center; width: 100%;">Page <span class="pageNumber"></span> of <span class="totalPages"></span></div>',
+  });
+
+  await writeFile('report.pdf', pdfBuffer);
+}
+```
+
+### Logging & Debugging
+
+Attach a logger to a context or page to automatically capture console messages, page errors, and network requests.
+
+```typescript
+import type { BrowserContextController } from '@tstdl/base/browser';
+import { Logger } from '@tstdl/base/logger';
+import { inject } from '@tstdl/base/injector';
+
+const logger = inject(Logger);
+
+function debugSession(context: BrowserContextController) {
+  // All pages created in this context will now log to the provided logger
+  context.attachLogger(logger);
+
+  // Console logs from the browser will appear in your node logs
+  // Network requests will be logged at verbose level
+}
+```
+
+### Smart Scrolling
+
+The `scrollTo` method intelligently scrolls the viewport to a specific element or coordinate, handling complex scrolling containers.
+
+```typescript
+import type { PageController } from '@tstdl/base/browser';
+
+async function scrollToFooter(page: PageController) {
+  const footer = page.getByRole('contentinfo');
+
+  // Smoothly scrolls until the element is in view
+  await page.scrollTo(footer);
+}
+```
+
+### Frame & Popup Handling
+
+Interacting with `<iframe>` elements or popups is straightforward using dedicated controllers.
+
+```typescript
+import type { PageController } from '@tstdl/base/browser';
+
+async function handleIframe(page: PageController) {
+  // Access an iframe by name, url, or index
+  const newsletterFrame = page.frame({ url: /.*newsletter.*/ });
+
+  // Use the same ElementController API inside the frame
+  await newsletterFrame.getByPlaceholder('Email').fill('user@example.com');
+  await newsletterFrame.getByRole('button', { name: 'Subscribe' }).click();
+}
+
+async function handlePopups(page: PageController) {
+  // Trigger an action that opens a popup
+  await page.getByRole('link', { name: 'Help' }).click();
+
+  // Find the newly opened page
+  const [helpPage] = await page.opened();
+
+  if (helpPage) {
+    console.log('Opened help page:', helpPage.url());
+    await helpPage.close();
+  }
+}
+```
+
+### Element Lifecycle & Existence
+
+`ElementController` provides helpful methods to check for elements without throwing errors on timeout immediately.
+
+```typescript
+import type { PageController } from '@tstdl/base/browser';
+
+async function checkStatus(page: PageController) {
+  const successMessage = page.getByText('Success!');
+
+  // Check if it exists and is visible within a short timeout
+  if (await successMessage.exists({ timeout: 2000 })) {
+    console.log('Operation completed successfully.');
+  } else {
+    console.warn('Success message did not appear.');
+  }
+}
+```
+
+## 📚 API
+
+### `BrowserService`
+
+Singleton service for managing browser instances.
+
+| Method                                | Description                                                           |
+| :------------------------------------ | :-------------------------------------------------------------------- |
+| `newBrowser(options?)`                | Launches a new `BrowserController`.                                   |
+| `newPersistentContext(dir, options?)` | Launches a browser with a persistent context for saving session data. |
+| `waitForNoBrowsers()`                 | Waits until all managed browsers are closed.                          |
+| `dispose()`                           | Closes all browsers and contexts created by this service.             |
+
+### `BrowserController`
+
+Controls a single browser process.
+
+| Method                 | Description                                         |
+| :--------------------- | :-------------------------------------------------- |
+| `newContext(options?)` | Creates a new, isolated `BrowserContextController`. |
+| `waitForNoContexts()`  | Waits until all contexts are closed.                |
+| `close()`              | Closes the browser and all its contexts.            |
+| `waitForClose()`       | Waits for the browser to close.                     |
+
+### `BrowserContextController`
+
+Controls an isolated browser session.
+
+| Method                         | Description                                              |
+| :----------------------------- | :------------------------------------------------------- |
+| `newPage(options?)`            | Creates a new `PageController` (tab).                    |
+| `pages()`                      | Returns all open pages in this context.                  |
+| `getControllerByPage(page)`    | Wraps a native Playwright `Page` in a `PageController`.  |
+| `getState()`                   | Returns the storage state (cookies, localStorage).       |
+| `setExtraHttpHeaders(headers)` | Sets headers for all requests in this context.           |
+| `attachLogger(logger)`         | Attaches a logger to monitor console and network events. |
+| `waitForNoPages()`             | Waits until all pages are closed.                       |
+| `close()`                      | Closes the context and all pages.                        |
+
+### `PageController`
+
+Controls a single tab. Extends `DocumentController`.
+
+| Method                         | Description                                            |
+| :----------------------------- | :----------------------------------------------------- |
+| `url()`                        | Returns the current URL.                               |
+| `opened()`                     | Returns pages opened by this page (e.g., popups).      |
+| `opener()`                     | Returns the page that opened this one.                 |
+| `navigate(url, options?)`      | Navigates to a URL.                                    |
+| `waitForUrl(url, options?)`    | Waits for the URL to match a predicate or string.      |
+| `waitForLoadState(state?)`     | Waits for the page to reach a specific load state.     |
+| `setContent(html, options?)`   | Sets the page content.                                 |
+| `renderPdf(options?)`          | Renders the page as a PDF `Uint8Array`.                |
+| `renderPdfStream(options?)`    | Renders the page as a PDF `ReadableStream`.            |
+| `scroll(deltaX, deltaY)`       | Scrolls using the mouse wheel.                         |
+| `scrollTo(target)`              | Scrolls to a coordinate or `ElementController`.        |
+| `frame(selector)`              | Gets a `FrameController` for an iframe.                |
+| `close()`                      | Closes the page.                                       |
+| `attachLogger(logger)`         | Attaches a logger to this specific page.               |
+
+### `FrameController`
+
+Controls a single iframe. Extends `DocumentController`.
+
+| Method              | Description                         |
+| :------------------ | :---------------------------------- |
+| `getPage()`         | Returns the page containing this frame. |
+| `getFrame(selector)`| Gets a child frame.                 |
+
+### `DocumentController`
+
+Base class for `PageController` and `FrameController`. Extends `LocatorController`.
+
+| Method                        | Description                                          |
+| :---------------------------- | :--------------------------------------------------- |
+| `evaluate(fn, arg?)`          | Executes JavaScript in the context of the document.  |
+| `frames()`                    | Returns all child frames.                            |
+| `getControllerByFrame(frame)` | Wraps a native Playwright `Frame` in a controller.   |
+| `waitForElement(selector)`    | Waits for an element to appear in the DOM.           |
+| `locateInFrame(selector)`     | Returns a `LocatorController` for an iframe.        |
+
+### `ElementController`
+
+Wraps a Playwright `Locator` or `ElementHandle`. Extends `LocatorController`.
+
+| Method                          | Description                                                 |
+| :------------------------------ | :---------------------------------------------------------- |
+| `exists(options?)`              | Checks if the element exists and is visible (configurable). |
+| `count()`                       | Returns the number of matching elements.                   |
+| `isVisible()`                   | Checks if the element is visible.                           |
+| `isHidden()`                    | Checks if the element is hidden.                            |
+| `isEnabled()`                   | Checks if the element is enabled.                           |
+| `isDisabled()`                  | Checks if the element is disabled.                          |
+| `isChecked()`                   | Checks if the element is checked (radio/checkbox).          |
+| `isEditable()`                  | Checks if the element is editable.                          |
+| `click(options?)`               | Clicks the element.                                         |
+| `dblclick(options?)`            | Double-clicks the element.                                  |
+| `fill(text, options?)`          | Fills an input.                                             |
+| `clear(options?)`               | Clears an input.                                            |
+| `type(text, options?)`          | Types text character by character.                          |
+| `press(key, options?)`          | Simulates a key press.                                      |
+| `check(options?)`               | Checks a checkbox or radio button.                          |
+| `uncheck(options?)`             | Unchecks a checkbox or radio button.                        |
+| `setChecked(checked, options?)` | Sets the checked state.                                     |
+| `selectOption(values, options?)`| Selects one or multiple options in a `<select>`.            |
+| `setInputFiles(files, options?)`| Sets files for a file input.                                |
+| `hover(options?)`               | Hovers over the element.                                    |
+| `focus(options?)`               | Focuses the element.                                        |
+| `tap(options?)`                 | Taps the element (touch).                                   |
+| `selectText(options?)`          | Selects the text in the element.                            |
+| `inputValue()`                  | Gets the current value of an input.                         |
+| `evaluate(fn, arg?)`            | Executes JavaScript in the context of the element.          |
+| `boundingBox()`                 | Returns the element's bounding box (x, y, width, height).   |
+| `scrollIntoViewIfNeeded()`      | Scrolls the element into view if it's not visible.           |
+| `filter(filter)`                | Narrow down the selection based on text or descendants.    |
+| `locate(selector)`              | Finds descendant elements.                                  |
+| `and(element)`                  | Combines two locators (intersection).                     |
+| `or(element)`                   | Combines two locators (union).                            |
+| `first()`                       | Returns the first matching element.                        |
+| `last()`                        | Returns the last matching element.                         |
+| `nth(index)`                    | Returns the nth matching element.                          |
+| `waitFor(state?)`               | Waits for a specific state (visible, attached, etc.).       |
+| `getAll()`                      | Returns an array of controllers for all matching elements.  |
+
+### `LocatorController`
+
+Base class for searching elements.
+
+| Method                 | Description                                    |
+| :--------------------- | :--------------------------------------------- |
+| `getBySelector(sel)`   | Finds element(s) by CSS selector.              |
+| `getByRole(role)`      | Finds element(s) by ARIA role.                  |
+| `getByLabel(text)`     | Finds element(s) by associated label text.     |
+| `getByPlaceholder(tx)` | Finds element(s) by placeholder text.          |
+| `getByText(text)`      | Finds element(s) by text content.              |
+| `getByAltText(text)`   | Finds element(s) by alt attribute.             |
+| `getByTitle(text)`     | Finds element(s) by title attribute.           |

package/cancellation/README.md

@@ -0,0 +1,156 @@
+# Cancellation (`@tstdl/base/cancellation`)
+
+A powerful and flexible cancellation signaling module for TypeScript, built on the native `AbortSignal` API. It provides a robust mechanism for managing cancellation in asynchronous operations, offering seamless integration with Promises, Observables, and the native `AbortController`.
+
+## ✨ Features
+
+- **Native Integration:** Built on top of the native `AbortSignal` for maximum compatibility with modern web and Node.js APIs.
+- **One-way Lifecycle:** Signals are one-way (once set, they stay set), simplifying state management and reasoning.
+- **Hierarchical:** Create child signals that inherit cancellation state from parents.
+- **Promise-friendly:** `await` a signal to pause execution until it is cancelled.
+- **Resource Management:** Automatic cleanup via the `Disposable` pattern (`Symbol.dispose`).
+- **Explicit Read/Write Separation:** Use `CancellationToken` to control state and `CancellationSignal` for a read-only view.
+
+## Core Concepts
+
+The module revolves around two main classes:
+
+1.  **`CancellationToken`**: A mutable cancellation source. It provides a `.set()` method to trigger cancellation.
+2.  **`CancellationSignal`**: A read-only view of a cancellation state. It allows checking if cancellation has occurred and waiting for it.
+
+A `CancellationToken` _is a_ `CancellationSignal`, but it has the additional ability to trigger the cancellation.
+
+The state of a signal is:
+
+- **Unset** (`isUnset` is true): The default state; the operation should continue.
+- **Set** (`isSet` is true): The cancelled state; the operation should stop.
+
+Once a signal is **Set**, it cannot be **Unset**.
+
+## 🚀 Basic Usage
+
+Create a `CancellationToken` to manage the lifecycle of an operation.
+
+```typescript
+import { CancellationToken } from '@tstdl/base/cancellation';
+
+const token = new CancellationToken();
+
+console.log(token.isSet); // false
+console.log(token.isUnset); // true
+
+// Pass the read-only signal to a consumer
+doWork(token.signal);
+
+// Some time later...
+token.set('User requested cancellation'); // Set the token to a cancelled state
+
+console.log(token.isSet); // true
+console.log(token.reason); // Error: Operation cancelled (cause: User requested cancellation)
+
+function doWork(signal: CancellationSignal) {
+  if (signal.isSet) {
+    return;
+  }
+  // ... perform work
+}
+```
+
+## 🔧 Advanced Topics
+
+### Promise Integration
+
+You can `await` a signal using the `.wait()` method. It returns a promise that resolves when the signal is set. By default, it throws the cancellation reason as an error.
+
+```typescript
+async function longRunningTask(signal: CancellationSignal) {
+  console.log('Task started.');
+
+  try {
+    // Wait for the signal to be set (will throw)
+    await signal.wait();
+  } catch (error) {
+    console.log('Task was cancelled:', error.message);
+    return;
+  }
+}
+```
+
+### Hierarchical Cancellation (Inheritance)
+
+Create a hierarchy of signals. When a parent signal is set, all its children are also set.
+
+```typescript
+const parent = new CancellationToken();
+
+// child1 inherits from parent
+const child1 = parent.fork();
+
+// child2 inherits from parent and another source
+const child2 = new CancellationToken([parent, otherSignal]);
+
+parent.set();
+console.log(child1.isSet); // true
+console.log(child2.isSet); // true
+```
+
+### Native `AbortSignal` Interoperability
+
+`CancellationSignal` wraps a native `AbortSignal` and can be created from any `AbortSignal` or `AbortController`.
+
+```typescript
+const controller = new AbortController();
+const signal = CancellationSignal.from(controller.signal);
+
+// Use the wrapped signal with fetch
+const response = await fetch(url, { signal: signal.abortSignal });
+```
+
+### Timeouts
+
+Easily create signals that automatically trigger after a timeout.
+
+```typescript
+const signal = parentSignal.withTimeout(5000); // Set after 5 seconds or if parent is set
+```
+
+### Cleanup and Disposal
+
+`CancellationSignal` and `CancellationToken` implement the `Disposable` interface. Disposing of a signal will abort its internal controller, effectively setting it.
+
+```typescript
+using token = new CancellationToken();
+// token will be disposed (and thus set) when the scope is exited
+```
+
+## 📚 API Reference
+
+### `CancellationSignal` (Read-only)
+
+| Member             | Type                 | Description                                                               |
+| :----------------- | :------------------- | :------------------------------------------------------------------------ |
+| `isSet`            | `boolean`            | Whether the signal is set (cancelled).                                    |
+| `isUnset`          | `boolean`            | Whether the signal is not yet set.                                        |
+| `reason`           | `any`                | The reason for cancellation (usually an `Error`).                         |
+| `abortSignal`      | `AbortSignal`        | The underlying native `AbortSignal`.                                      |
+| `wait(options?)`   | `Promise<void>`      | Returns a promise that resolves when the signal is set.                   |
+| `throwIfSet()`     | `void`               | Throws the `reason` if the signal is set.                                 |
+| `fork()`           | `CancellationToken`  | Creates a new `CancellationToken` that inherits from this signal.         |
+| `inherit(sources)` | `CancellationSignal` | Creates a new signal that is set when this or any of the sources are set. |
+| `withTimeout(ms)`  | `CancellationSignal` | Creates a new signal that is set after a timeout.                         |
+| `dispose()`        | `void`               | Manually disposes of the signal (sets it).                                |
+
+### `CancellationToken` (Writable)
+
+Extends `CancellationSignal`.
+
+| Member                  | Type                 | Description                                                     |
+| :---------------------- | :------------------- | :-------------------------------------------------------------- |
+| `constructor(parents?)` | -                    | Creates a new token, optionally inheriting from parent sources. |
+| `set(reason?)`          | `void`               | Triggers cancellation with an optional reason.                  |
+| `signal`                | `CancellationSignal` | Returns a read-only view of this token.                         |
+
+### `CancellationSource` (Type)
+
+A union type representing any object that can be used as a source for cancellation:
+`CancellationToken | CancellationSignal | AbortController | AbortSignal`

package/cancellation/tests/coverage.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/cancellation/tests/coverage.test.js

@@ -0,0 +1,49 @@
+import '../../polyfills.js';
+import { describe, expect, it, vi } from 'vitest';
+import * as core from '../../core.js';
+import { CancellationToken, sourcesToAbortSignal } from '../token.js';
+describe('Cancellation Coverage Extra', () => {
+    it('should hit dev mode branch (true)', () => {
+        vi.spyOn(core, 'isDevMode').mockReturnValue(true);
+        const token = new CancellationToken();
+        expect(token.isSet).toBe(false);
+    });
+    it('should hit dev mode branch (false)', () => {
+        vi.spyOn(core, 'isDevMode').mockReturnValue(false);
+        const token = new CancellationToken();
+        expect(token.isSet).toBe(false);
+    });
+    it('should hit throw: true branch in wait', async () => {
+        const token = new CancellationToken();
+        token.set('reason');
+        await expect(token.wait({ throw: true })).rejects.toThrow();
+    });
+    it('should hit waitThrow', async () => {
+        const token = new CancellationToken();
+        token.set('reason');
+        await expect(token.waitThrow()).rejects.toThrow();
+    });
+    it('should hit signals.length == 1 branch', () => {
+        const controller = new AbortController();
+        const signal = sourcesToAbortSignal(controller.signal);
+        expect(signal).toBe(controller.signal);
+    });
+    it('should hit signals.length > 1 branch', () => {
+        const controller1 = new AbortController();
+        const controller2 = new AbortController();
+        const signal = sourcesToAbortSignal([controller1.signal, controller2.signal]);
+        expect(signal).not.toBe(controller1.signal);
+        expect(signal).not.toBe(controller2.signal);
+    });
+    it('should hit sourcesToAbortSignal error branch', () => {
+        expect(() => sourcesToAbortSignal([])).toThrow('At least one cancellation source must be provided');
+    });
+    it('should hit unsubscribe branch in subscribe', () => {
+        const token = new CancellationToken();
+        const next = vi.fn();
+        const subscription = token.subscribe({ next });
+        subscription.unsubscribe();
+        token.set();
+        expect(next).not.toHaveBeenCalled();
+    });
+});

package/cancellation/tests/leak.test.js

@@ -1,40 +1,35 @@
 import { describe, expect, it } from 'vitest';
-import { CancellationToken } from '../token.js';
+import { CancellationSignal, CancellationToken } from '../token.js';
 describe('CancellationToken Memory Leak', () => {
-    it('should not leak subscriptions in connect', () => {
+    it('should not leak when using inherit and disposing', () => {
         const parent = new CancellationToken();
-        // @ts-ignore
-        const initialParentSubscribers = parent._stateSubject.observers.length;
         for (let i = 0; i < 1000; i++) {
-            const child = new CancellationToken();
-            parent.connect(child, { once: true });
-            child.set();
+            const child = parent.inherit(new CancellationToken());
+            child.dispose();
         }
-        // @ts-ignore
-        expect(parent._stateSubject.observers.length).toBeLessThan(initialParentSubscribers + 10);
+        expect(parent.isSet).toBe(false);
     });
-    it('should not leak when child is completed', () => {
+    it('should follow parent signal', () => {
         const parent = new CancellationToken();
-        const child = new CancellationToken();
-        parent.connect(child);
-        // @ts-ignore
-        expect(parent._stateSubject.observers.length).toBe(1);
-        child.complete();
-        // @ts-ignore
-        expect(parent._stateSubject.observers.length).toBe(0);
+        const child = new CancellationToken(parent);
+        expect(child.isSet).toBe(false);
+        parent.set();
+        expect(child.isSet).toBe(true);
     });
-    it('should not leak when parent is completed', () => {
+    it('should not affect parent when child is set', () => {
         const parent = new CancellationToken();
-        const child = new CancellationToken();
-        parent.connect(child);
-        // @ts-ignore
-        expect(parent._stateSubject.observers.length).toBeGreaterThan(0);
-        // @ts-ignore
-        expect(child._stateSubject.observers.length).toBeGreaterThan(0);
-        parent.complete();
-        // @ts-ignore
-        expect(parent._stateSubject.observers.length).toBe(0);
-        // @ts-ignore
-        expect(child._stateSubject.observers.length).toBe(0);
+        const child = new CancellationToken(parent);
+        expect(parent.isSet).toBe(false);
+        child.set();
+        expect(parent.isSet).toBe(false);
+        expect(child.isSet).toBe(true);
+    });
+    it('should clean up when disposed', () => {
+        const parent = new CancellationToken();
+        const signal = CancellationSignal.from(parent);
+        expect(signal.isSet).toBe(false);
+        signal.dispose();
+        expect(signal.isSet).toBe(true);
+        expect(parent.isSet).toBe(false);
     });
 });

package/cancellation/tests/token.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';