@remotion/renderer 3.0.25 → 3.0.28

package/dist/browser/AriaQueryHandler.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ariaHandler = void 0;
+const assert_1 = require("./assert");
+async function queryAXTree(client, element, accessibleName, role) {
+    const { nodes } = await client.send('Accessibility.queryAXTree', {
+        objectId: element._remoteObject.objectId,
+        accessibleName,
+        role,
+    });
+    const filteredNodes = nodes.filter((node) => {
+        return !node.role || node.role.value !== 'StaticText';
+    });
+    return filteredNodes;
+}
+const normalizeValue = (value) => {
+    return value.replace(/ +/g, ' ').trim();
+};
+const knownAttributes = new Set(['name', 'role']);
+const attributeRegexp = /\[\s*(?<attribute>\w+)\s*=\s*(?<quote>"|')(?<value>\\.|.*?(?=\k<quote>))\k<quote>\s*\]/g;
+function isKnownAttribute(attribute) {
+    return knownAttributes.has(attribute);
+}
+/*
+ * The selectors consist of an accessible name to query for and optionally
+ * further aria attributes on the form `[<attribute>=<value>]`.
+ * Currently, we only support the `name` and `role` attribute.
+ * The following examples showcase how the syntax works wrt. querying:
+ * - 'title[role="heading"]' queries for elements with name 'title' and role 'heading'.
+ * - '[role="img"]' queries for elements with role 'img' and any name.
+ * - 'label' queries for elements with name 'label' and any role.
+ * - '[name=""][role="button"]' queries for elements with no name and role 'button'.
+ */
+function parseAriaSelector(selector) {
+    const queryOptions = {};
+    const defaultName = selector.replace(attributeRegexp, (_, attribute, _quote, value) => {
+        attribute = attribute.trim();
+        (0, assert_1.assert)(isKnownAttribute(attribute), `Unknown aria attribute "${attribute}" in selector`);
+        queryOptions[attribute] = normalizeValue(value);
+        return '';
+    });
+    if (defaultName && !queryOptions.name) {
+        queryOptions.name = normalizeValue(defaultName);
+    }
+    return queryOptions;
+}
+const queryOne = async (element, selector) => {
+    const exeCtx = element.executionContext();
+    const { name, role } = parseAriaSelector(selector);
+    const res = await queryAXTree(exeCtx._client, element, name, role);
+    if (!res[0] || !res[0].backendDOMNodeId) {
+        return null;
+    }
+    return exeCtx._adoptBackendNodeId(res[0].backendDOMNodeId);
+};
+const waitFor = (domWorld, selector, options) => {
+    const binding = {
+        name: 'ariaQuerySelector',
+        pptrFunction: async (_selector) => {
+            const root = options.root || (await domWorld._document());
+            const element = await queryOne(root, _selector);
+            return element;
+        },
+    };
+    return domWorld._waitForSelectorInPage((_, _selector) => {
+        return globalThis.ariaQuerySelector(_selector);
+    }, selector, options, binding);
+};
+const queryAll = async (element, selector) => {
+    const exeCtx = element.executionContext();
+    const { name, role } = parseAriaSelector(selector);
+    const res = await queryAXTree(exeCtx._client, element, name, role);
+    return Promise.all(res.map((axNode) => {
+        return exeCtx._adoptBackendNodeId(axNode.backendDOMNodeId);
+    }));
+};
+const queryAllArray = async (element, selector) => {
+    const elementHandles = await queryAll(element, selector);
+    const exeCtx = element.executionContext();
+    const jsHandle = exeCtx.evaluateHandle((...elements) => {
+        return elements;
+    }, ...elementHandles);
+    return jsHandle;
+};
+/**
+ * @internal
+ */
+exports._ariaHandler = {
+    queryOne,
+    waitFor,
+    queryAll,
+    queryAllArray,
+};

package/dist/browser/Browser.d.ts

@@ -22,6 +22,11 @@ declare type BrowserCloseCallback = () => Promise<void> | void;
 interface WaitForTargetOptions {
     timeout?: number;
 }
+export declare const enum BrowserEmittedEvents {
+    TargetChanged = "targetchanged",
+    TargetCreated = "targetcreated",
+    Closed = "closed"
+}
 export declare class Browser extends EventEmitter {
     #private;
     static _create({ connection, contextIds, defaultViewport, closeCallback, }: {

package/dist/browser/Browser.js

@@ -111,7 +111,7 @@ class Browser extends EventEmitter_1.EventEmitter {
                 return await targetPromise;
             }
             this.targets().forEach(check);
-            return await (0, util_1.waitWithTimeout)(targetPromise, 'target', timeout);
+            return await (0, util_1.waitWithTimeout)(targetPromise, 'target', timeout, this);
         }
         finally {
             this.off("targetcreated" /* BrowserEmittedEvents.TargetCreated */, check);
@@ -136,6 +136,7 @@ class Browser extends EventEmitter_1.EventEmitter {
     async close() {
         await __classPrivateFieldGet(this, _Browser_closeCallback, "f").call(null);
         this.disconnect();
+        this.emit("closed" /* BrowserEmittedEvents.Closed */);
     }
     disconnect() {
         __classPrivateFieldGet(this, _Browser_connection, "f").dispose();

package/dist/browser/Connection.d.ts

@@ -1,5 +1,5 @@
-import type { Protocol } from 'devtools-protocol';
-import type { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping';
+import type { Commands } from './devtools-commands';
+import type { TargetInfo } from './devtools-types';
 import { EventEmitter } from './EventEmitter';
 import type { NodeWebSocketTransport } from './NodeWebSocketTransport';
 export declare class Connection extends EventEmitter {
@@ -7,14 +7,14 @@ export declare class Connection extends EventEmitter {
     constructor(transport: NodeWebSocketTransport);
     static fromSession(session: CDPSession): Connection | undefined;
     session(sessionId: string): CDPSession | null;
-    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+    send<T extends keyof Commands>(method: T, ...paramArgs: Commands[T]['paramsType']): Promise<Commands[T]['returnType']>;
     _rawSend(message: Record<string, unknown>): number;
     dispose(): void;
     /**
      * @param targetInfo - The target info
      * @returns The CDP session that is created
      */
-    createSession(targetInfo: Protocol.Target.TargetInfo): Promise<CDPSession>;
+    createSession(targetInfo: TargetInfo): Promise<CDPSession>;
 }
 interface CDPSessionOnMessageObject {
     id?: number;
@@ -34,7 +34,7 @@ export declare class CDPSession extends EventEmitter {
     #private;
     constructor(connection: Connection, targetType: string, sessionId: string);
     connection(): Connection | undefined;
-    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+    send<T extends keyof Commands>(method: T, ...paramArgs: Commands[T]['paramsType']): Promise<Commands[T]['returnType']>;
     _onMessage(object: CDPSessionOnMessageObject): void;
     _onClosed(): void;
     id(): string;

package/dist/browser/Coverage.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+import { PuppeteerEventListener } from './util';
+/**
+ * @internal
+ */
+export { PuppeteerEventListener };
+/**
+ * The CoverageEntry class represents one entry of the coverage report.
+ * @public
+ */
+export interface CoverageEntry {
+    /**
+     * The URL of the style sheet or script.
+     */
+    url: string;
+    /**
+     * The content of the style sheet or script.
+     */
+    text: string;
+    /**
+     * The covered range as start and end positions.
+     */
+    ranges: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+/**
+ * The CoverageEntry class for JavaScript
+ * @public
+ */
+export interface JSCoverageEntry extends CoverageEntry {
+    /**
+     * Raw V8 script coverage entry.
+     */
+    rawScriptCoverage?: Protocol.Profiler.ScriptCoverage;
+}
+/**
+ * Set of configurable options for JS coverage.
+ * @public
+ */
+export interface JSCoverageOptions {
+    /**
+     * Whether to reset coverage on every navigation.
+     */
+    resetOnNavigation?: boolean;
+    /**
+     * Whether anonymous scripts generated by the page should be reported.
+     */
+    reportAnonymousScripts?: boolean;
+    /**
+     * Whether the result includes raw V8 script coverage entries.
+     */
+    includeRawScriptCoverage?: boolean;
+}
+/**
+ * Set of configurable options for CSS coverage.
+ * @public
+ */
+export interface CSSCoverageOptions {
+    /**
+     * Whether to reset coverage on every navigation.
+     */
+    resetOnNavigation?: boolean;
+}
+/**
+ * The Coverage class provides methods to gathers information about parts of
+ * JavaScript and CSS that were used by the page.
+ *
+ * @remarks
+ * To output coverage in a form consumable by {@link https://github.com/istanbuljs | Istanbul},
+ * see {@link https://github.com/istanbuljs/puppeteer-to-istanbul | puppeteer-to-istanbul}.
+ *
+ * @example
+ * An example of using JavaScript and CSS coverage to get percentage of initially
+ * executed code:
+ * ```js
+ * // Enable both JavaScript and CSS coverage
+ * await Promise.all([
+ *   page.coverage.startJSCoverage(),
+ *   page.coverage.startCSSCoverage()
+ * ]);
+ * // Navigate to page
+ * await page.goto('https://example.com');
+ * // Disable both JavaScript and CSS coverage
+ * const [jsCoverage, cssCoverage] = await Promise.all([
+ *   page.coverage.stopJSCoverage(),
+ *   page.coverage.stopCSSCoverage(),
+ * ]);
+ * let totalBytes = 0;
+ * let usedBytes = 0;
+ * const coverage = [...jsCoverage, ...cssCoverage];
+ * for (const entry of coverage) {
+ *   totalBytes += entry.text.length;
+ *   for (const range of entry.ranges)
+ *     usedBytes += range.end - range.start - 1;
+ * }
+ * console.log(`Bytes used: ${usedBytes / totalBytes * 100}%`);
+ * ```
+ * @public
+ */
+export declare class Coverage {
+    #private;
+    constructor(client: CDPSession);
+    /**
+     * @param options - Set of configurable options for coverage defaults to
+     * `resetOnNavigation : true, reportAnonymousScripts : false`
+     * @returns Promise that resolves when coverage is started.
+     *
+     * @remarks
+     * Anonymous scripts are ones that don't have an associated url. These are
+     * scripts that are dynamically created on the page using `eval` or
+     * `new Function`. If `reportAnonymousScripts` is set to `true`, anonymous
+     * scripts will have `pptr://__puppeteer_evaluation_script__` as their URL.
+     */
+    startJSCoverage(options?: JSCoverageOptions): Promise<void>;
+    /**
+     * @returns Promise that resolves to the array of coverage reports for
+     * all scripts.
+     *
+     * @remarks
+     * JavaScript Coverage doesn't include anonymous scripts by default.
+     * However, scripts with sourceURLs are reported.
+     */
+    stopJSCoverage(): Promise<JSCoverageEntry[]>;
+    /**
+     * @param options - Set of configurable options for coverage, defaults to
+     * `resetOnNavigation : true`
+     * @returns Promise that resolves when coverage is started.
+     */
+    startCSSCoverage(options?: CSSCoverageOptions): Promise<void>;
+    /**
+     * @returns Promise that resolves to the array of coverage reports
+     * for all stylesheets.
+     * @remarks
+     * CSS Coverage doesn't include dynamically injected style tags
+     * without sourceURLs.
+     */
+    stopCSSCoverage(): Promise<CoverageEntry[]>;
+}
+/**
+ * @public
+ */
+export declare class JSCoverage {
+    #private;
+    constructor(client: CDPSession);
+    start(options?: {
+        resetOnNavigation?: boolean;
+        reportAnonymousScripts?: boolean;
+        includeRawScriptCoverage?: boolean;
+    }): Promise<void>;
+    stop(): Promise<JSCoverageEntry[]>;
+}
+/**
+ * @public
+ */
+export declare class CSSCoverage {
+    #private;
+    constructor(client: CDPSession);
+    start(options?: {
+        resetOnNavigation?: boolean;
+    }): Promise<void>;
+    stop(): Promise<CoverageEntry[]>;
+}