@rindo/core 1.8.12

package/dist/testing/puppeteer/puppeteer-declarations.d.ts

@@ -0,0 +1,396 @@
+/// <reference types="node" />
+import * as d from '../../declarations';
+import * as puppeteer from 'puppeteer';
+export interface NewE2EPageOptions extends puppeteer.NavigationOptions {
+    url?: string;
+    html?: string;
+    failOnConsoleError?: boolean;
+    failOnNetworkError?: boolean;
+}
+declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+declare type PuppeteerPage = Omit<puppeteer.Page, 'bringToFront' | 'browser' | 'screenshot' | 'emulate' | 'emulateMedia' | 'frames' | 'goBack' | 'goForward' | 'isClosed' | 'mainFrame' | 'pdf' | 'reload' | 'target' | 'title' | 'viewport' | 'waitForNavigation' | 'screenshot' | 'workers' | 'addListener' | 'prependListener' | 'prependOnceListener' | 'removeListener' | 'removeAllListeners' | 'setMaxListeners' | 'getMaxListeners' | 'listeners' | 'rawListeners' | 'emit' | 'eventNames' | 'listenerCount' | '$x' | 'waitForXPath'>;
+export interface PageDiagnostic {
+    type: 'error' | 'pageerror' | 'requestfailed';
+    message?: string;
+    location?: string;
+}
+/**
+ * The E2EPage is a wrapper utility to Puppeteer in order to
+ * to create easier to write and read end-to-end tests.
+ */
+export interface E2EPage extends PuppeteerPage {
+    /**
+     * `Experimental`
+     * Takes a screenshot of the page, then compares the current screenshot
+     * against the master screenshot. The returned screenshot compare
+     * results can then be used to test pixel mismatches, such as
+     * `expect(results).toMatchScreenshot()`.
+     */
+    compareScreenshot(): Promise<d.ScreenshotDiff>;
+    /**
+     * `Experimental`
+     * Takes a screenshot of the page, then compares the current screenshot
+     * against the master screenshot. The provided `description` will be
+     * added onto its current description, which comes from the test description.
+     */
+    compareScreenshot(description: string): Promise<d.ScreenshotDiff>;
+    /**
+     * `Experimental`
+     * Takes a screenshot of the page, then compares the current screenshot
+     * against the master screenshot. The `opts` argument can be used to
+     * customize screenshot options.
+     */
+    compareScreenshot(opts: d.ScreenshotOptions): Promise<d.ScreenshotDiff>;
+    /**
+     * `Experimental`
+     * Takes a screenshot of the page, then compares the current screenshot
+     * against the master screenshot. The `description` argument will be
+     * added onto its current description, which comes from the test description.
+     * The `opts` argument can be used to customize screenshot options.
+     */
+    compareScreenshot(description: string, opts: d.ScreenshotOptions): Promise<d.ScreenshotDiff>;
+    /**
+     * Sets a debugger;
+     */
+    debugger(): Promise<void>;
+    /**
+     * Find an element that matches the selector, which is the same as
+     * `document.querySelector(selector)`. Use `>>>` within the
+     * selector to find an element within the host element's shadow root.
+     * For example, to select the first `div` inside of the component
+     * `my-cmp`, the call would be `page.find('my-cmp >>> div')`.
+     * Returns `null` if an element was not found.
+     */
+    find(selector: FindSelector): Promise<E2EElement>;
+    /**
+     * Find all elements that match the selector, which is the same as
+     * `document.querySelectorAll(selector)`. Use `>>>` within the
+     * selector to find elements within the host element's shadow root.
+     * For example, to select all of the `li` elements inside of the component
+     * `my-cmp`, the call would be `page.findAll('my-cmp >>> li')`.
+     * Returns an empty array if no elements were found.
+     */
+    findAll(selector: string): Promise<E2EElement[]>;
+    /**
+     * During an end-to-end test, a dev-server is started so `page.goto(url)` can be used
+     * on the app being tested. Urls are always relative since the dev server provides
+     * a localhost address. A shortcut to `page.goto(url)` is to set the `url` option
+     * when creating a new page, such as `const page = await newE2EPage({ url })`.
+     */
+    goTo(url: string, options?: puppeteer.NavigationOptions): Promise<puppeteer.Response | null>;
+    /**
+     * Instead of testing a url directly, html content can be mocked using
+     * `page.setContent(html)`. A shortcut to `page.setContent(html)` is to set
+     * the `html` option when creating a new page, such as
+     * `const page = await newE2EPage({ html })`.
+     */
+    setContent(html: string, options?: puppeteer.NavigationOptions): Promise<void>;
+    /**
+     * Used to test if an event was, or was not dispatched. This method
+     * returns a promise, that resolves with an EventSpy. The EventSpy
+     * can be used along with `expect(spy).toHaveReceivedEvent()`,
+     * `expect(spy).toHaveReceivedEventTimes(x)` and
+     * `expect(spy).toHaveReceivedEventDetail({...})`.
+     */
+    spyOnEvent(eventName: string, selector?: 'window' | 'document'): Promise<d.EventSpy>;
+    /**
+     * Both Rindo and Puppeteer have an asynchronous architecture, which is a good thing
+     * for performance. Since all calls are async, it's required that
+     * `await page.waitForChanges()` is called when changes are made to components.
+     * An error will be thrown if changes were made to a component but `waitForChanges()`
+     * was not called.
+     */
+    waitForChanges(): Promise<void>;
+    /**
+     * Waits for the event to be received on `window`. The optional second argument
+     * allows the listener to be set to `document` if needed.
+     */
+    waitForEvent(eventName: string): Promise<any>;
+    getDiagnostics(): PageDiagnostic[];
+}
+export interface E2EPageInternal extends E2EPage {
+    isClosed(): boolean;
+    _e2eElements: E2EElementInternal[];
+    _e2eEvents: Map<number, WaitForEvent>;
+    _e2eEventIds: number;
+    _e2eGoto(url: string, options?: Partial<puppeteer.NavigationOptions>): Promise<puppeteer.Response | null>;
+    _e2eClose(options?: puppeteer.PageCloseOptions): Promise<void>;
+    screenshot(options?: puppeteer.ScreenshotOptions): Promise<Buffer>;
+}
+export interface E2EElement {
+    /**
+     * Used to call a method on a component. For example, if a component
+     * has the method `cmp.myMethod(arg1, arg2)`, calling this method
+     * from a e2e test could be `cmp.callMethod('myMethod', arg1, arg2)`.
+     */
+    callMethod(methodName: string, ...methodArgs: any[]): Promise<any>;
+    /**
+     * Gets and sets the value of the class attribute of the e2e element.
+     * Note that `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    className: string;
+    /**
+     * Using classList is a convenient alternative to accessing an element's list
+     * of classes as a space-delimited string via `element.className`.
+     */
+    classList: {
+        /**
+         * Add specified class values. If these classes already exist in
+         * attribute of the element, then they are ignored.
+         */
+        add: (...tokens: string[]) => void;
+        /**
+         * Remove specified class values. Note: Removing a class that does
+         * not exist does NOT throw an error.
+         */
+        remove: (...tokens: string[]) => void;
+        /**
+         * If class exists then remove it, if not, then add it.
+         */
+        toggle: (token: string) => void;
+        /**
+         * Checks if specified class value exists in class attribute of the element.
+         */
+        contains: (className: string) => boolean;
+    };
+    /**
+     * Calling `click()` on an element scrolls it into view if needed, and
+     * then uses `page.mouse` to click in the center of the element.
+     * Please see the puppeteer docs for more information.
+     */
+    click(options?: puppeteer.ClickOptions): Promise<void>;
+    /**
+     * Find a child element that matches the selector, which is the same as
+     * `element.querySelector(selector)`. Use `>>>` within the
+     * selector to find an element within a host element's shadow root.
+     * For example, to select the first `div` inside of the component
+     * `my-cmp`, which is a child of this element, the call would be
+     * `element.find('my-cmp >>> div')`. Returns `null` if no
+     * elements were found.
+     */
+    find(selector: FindSelector): Promise<E2EElement>;
+    /**
+     * Find all child elements that match the selector, which is the same as
+     * `element.querySelectorAll(selector)`. Use `>>>` within the
+     * selector to find elements within a host element's shadow root.
+     * For example, to select all `li` elements inside of the component
+     * `my-cmp`, which is a child of this element, the call would be
+     * `element.findAll('my-cmp >>> li')`. Returns an empty array if
+     * no elements were found.
+     */
+    findAll(selector: FindSelector): Promise<E2EElement[]>;
+    /**
+     * Sets focus on the element.
+     */
+    focus(): Promise<void>;
+    /**
+     * Returns the value of a specified attribute on the element. If the
+     * given attribute does not exist, the value returned will be null.
+     */
+    getAttribute(name: string): string;
+    /**
+     * Used to get a property set on a component. For example, if a
+     * component has the property `elm.myProp`, then calling
+     * `elm.getProperty('myProp')` would return the `myProp` property value.
+     */
+    getProperty(propertyName: string): Promise<any>;
+    /**
+     * Returns an object that reports the values of all CSS properties of this
+     * element after applying active stylesheets and resolving any basic computation
+     * those values may contain. Individual CSS property values are accessed by
+     * simply indexing with CSS property names. The method is shortcut and an async
+     * version of using `window.getComputedStyle(element)` directly.
+     */
+    getComputedStyle(pseudoElt?: string | null): Promise<CSSStyleDeclaration>;
+    /**
+     * Sets hover on the element.
+     */
+    hover(): Promise<void>;
+    /**
+     * Gets and sets `id` property of the element.
+     * Note that `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    id: string;
+    /**
+     * Gets and sets `innerHTML` property of the element.
+     * Note that `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    innerHTML: string;
+    /**
+     * Gets and sets `innerText` property of the element.
+     * Note that `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    innerText: string;
+    /**
+     * Resolves to true if the element is visible in the current viewport.
+     */
+    isIntersectingViewport(): Promise<boolean>;
+    /**
+     * Resolves `true` when the element's style is `display !== 'none'`,
+     * `visibility !== 'hidden'` and `opacity !== '0'`.
+     */
+    isVisible(): Promise<boolean>;
+    /**
+     * Node name of the node, which in an element's case is the tag name.
+     * Note, this will always be upper-cased.
+     */
+    nodeName: string;
+    /**
+     * The type of a node represented by a number.
+     * Element = 1, TextNode = 3, Comment = 8,
+     * Document Fragment (also what a shadow root is) = 11.
+     */
+    nodeType: number;
+    /**
+     * Gets the element's `outerHTML. This is a read-only property and will
+     * throw an error if set.
+     */
+    outerHTML: string;
+    /**
+     * Focuses the element, and then uses `keyboard.down` and `keyboard.up`.
+     * If key is a single character and no modifier keys besides Shift are
+     * being held down, a keypress/input event will also be generated. The
+     * text option can be specified to force an input event to be generated.
+     * Note: Modifier keys DO effect `elementHandle.press`. Holding down Shift
+     * will type the text in upper case.
+     * Key names: https://github.com/GoogleChrome/puppeteer/blob/master/lib/USKeyboardLayout.js
+     */
+    press(key: string, options?: {
+        text?: string;
+        delay?: number;
+    }): Promise<void>;
+    /**
+     * Removes the attribute on the specified element. Note that
+     * `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    removeAttribute(name: string): void;
+    /**
+     * Sets the value of an attribute on the specified element. If the
+     * attribute already exists, the value is updated; otherwise a new
+     * attribute is added with the specified name and value. The value
+     * will always be converted to a string. Note that
+     * `await page.waitForChanges()` must be called before reading
+     * the value if content has changed.
+     */
+    setAttribute(name: string, value: any): void;
+    /**
+     * Used to set a property set on a component. For example, if a
+     * component has the property `elm.myProp`, then calling
+     * `elm.setProperty('myProp', 88)` would set the value `88` to
+     * the `myProp` property on the component.
+     */
+    setProperty(propertyName: string, value: any): void;
+    /**
+     * The ShadowRoot interface of the Shadow DOM API is the root node of a
+     * DOM subtree that is rendered separately from a document's main DOM tree.
+     * This value will be `null` if the element does not have a `shadowRoot`.
+     */
+    shadowRoot: ShadowRoot;
+    /**
+     * Used to test if an event was, or was not dispatched. This method
+     * returns a promise, that resolves with an EventSpy. The EventSpy
+     * can be used along with `expect(spy).toHaveReceivedEvent()`,
+     * `expect(spy).toHaveReceivedEventTimes(x)` and
+     * `expect(spy).toHaveReceivedEventDetail({...})`.
+     */
+    spyOnEvent(eventName: string): Promise<d.EventSpy>;
+    /**
+     * Represents the tab order of the current element. Setting the
+     * `tabIndex` property will also set the `tabindex` attribute.
+     */
+    tabIndex: number;
+    /**
+     * Tag name of the element. Note, this will always be upper-cased.
+     */
+    tagName: string;
+    /**
+     * This method scrolls the element it into view if needed,
+     * and then uses `page.touchscreen` to tap in the center of the element.
+     */
+    tap(): Promise<void>;
+    /**
+     * The `textContent` property represents the text content of a node
+     * and its descendants. Note that `await page.waitForChanges()` must
+     * be called before reading the value if content has changed.
+     */
+    textContent: string;
+    /**
+     * Represents the `title` of the element, the text usually displayed in a
+     * 'tool tip' popup when the mouse is over the displayed node.
+     */
+    title: string;
+    /**
+     * Toggles a `boolean` attribute (removing it if it is present and adding
+     * it if it is not present) on the given element. Note that
+     * `await page.waitForChanges()` must be called before reading
+     * the value if content has changed. The optional `force` argument is a
+     * `boolean` value to determine whether the attribute should be added or
+     * removed, no matter whether the attribute is present or not at the moment.
+     */
+    toggleAttribute(name: string, force?: boolean): void;
+    /**
+     * This is a convenience method to easily create a `CustomEvent`,
+     * and dispatch it from the element, to include any custom event
+     * `detail` data as the second argument.
+     */
+    triggerEvent(eventName: string, eventInitDict?: d.EventInitDict): void;
+    /**
+     * Sends a keydown, keypress/input, and keyup event for each character in the text.
+     * To press a special key, like Control or ArrowDown, use `keyboard.press`.
+     */
+    type(text: string, options?: {
+        delay: number;
+    }): Promise<void>;
+    /**
+     * Waits until the element's style is `display !== 'none'`,
+     * `visibility !== 'hidden'`, `opacity !== '0'` and the element
+     * is connected to the document.
+     */
+    waitForVisible(): Promise<void>;
+    /**
+     * Waits until the element's style is `display === 'none'`, or
+     * `visibility === 'hidden'`, or `opacity === '0'`, or the element
+     * is no longer connected to the document.
+     */
+    waitForNotVisible(): Promise<void>;
+    /**
+     * Waits until the given event is listened in the element.
+     */
+    waitForEvent(eventName: string): Promise<any>;
+}
+export interface E2EElementInternal extends E2EElement {
+    e2eDispose(): Promise<void>;
+    e2eRunActions(): Promise<void>;
+    e2eSync(): Promise<void>;
+}
+export declare type FindSelector = string | FindSelectorOptions;
+export interface FindSelectorOptions {
+    /**
+     * Finds an element with text content matching this
+     * exact value after the whitespace has been trimmed.
+     */
+    text?: string;
+    /**
+     * Finds an element with text content containing this value.
+     */
+    contains?: string;
+}
+export interface WaitForEventOptions {
+    timeout?: number;
+}
+export interface WaitForEvent {
+    eventName: string;
+    callback: (ev: any) => void;
+}
+export interface BrowserWindow extends Window {
+    rindoOnEvent(id: number, event: any): void;
+    rindoSerializeEvent(ev: CustomEvent): any;
+    rindoSerializeEventTarget(target: any): any;
+    rindoAppLoaded: boolean;
+}
+export {};

package/dist/testing/puppeteer/puppeteer-element.d.ts

@@ -0,0 +1,65 @@
+import * as d from '../../declarations';
+import * as pd from './puppeteer-declarations';
+import * as puppeteer from 'puppeteer';
+import { EventSpy } from './puppeteer-events';
+import { MockHTMLElement } from '@mock-doc';
+export declare class E2EElement extends MockHTMLElement implements pd.E2EElementInternal {
+    private _page;
+    private _elmHandle;
+    private _queuedActions;
+    private _queueAction;
+    constructor(_page: pd.E2EPageInternal, _elmHandle: puppeteer.ElementHandle);
+    find(selector: string): Promise<E2EElement>;
+    findAll(selector: string): Promise<E2EElement[]>;
+    callMethod(methodName: string, ...methodArgs: any[]): Promise<any>;
+    triggerEvent(eventName: string, eventInitDict?: d.EventInitDict): void;
+    spyOnEvent(eventName: string): Promise<EventSpy>;
+    click(options?: puppeteer.ClickOptions): Promise<void>;
+    focus(): Promise<void>;
+    hover(): Promise<void>;
+    isVisible(): Promise<boolean>;
+    waitForEvent(eventName: string): Promise<any>;
+    waitForVisible(): Promise<void>;
+    waitForNotVisible(): Promise<void>;
+    isIntersectingViewport(): Promise<boolean>;
+    press(key: string, options?: {
+        text?: string;
+        delay?: number;
+    }): Promise<void>;
+    tap(): Promise<void>;
+    type(text: string, options?: {
+        delay: number;
+    }): Promise<void>;
+    getProperty(propertyName: string): Promise<any>;
+    setProperty(propertyName: string, value: any): void;
+    getAttribute(name: string): any;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    toggleAttribute(name: string, force?: boolean): void;
+    get classList(): any;
+    get className(): string;
+    set className(value: string);
+    get id(): string;
+    set id(value: string);
+    get innerHTML(): string;
+    set innerHTML(value: string);
+    get innerText(): string;
+    set innerText(value: string);
+    get nodeValue(): string;
+    set nodeValue(value: string);
+    get outerHTML(): any;
+    set outerHTML(_: any);
+    get shadowRoot(): any;
+    set shadowRoot(value: any);
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    get textContent(): string;
+    set textContent(value: string);
+    get title(): string;
+    set title(value: string);
+    getComputedStyle(pseudoElt?: string | null): Promise<any>;
+    e2eRunActions(): Promise<any>;
+    e2eSync(): Promise<void>;
+    private _validate;
+    e2eDispose(): Promise<void>;
+}

package/dist/testing/puppeteer/puppeteer-emulate.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function setScreenshotEmulateData(userEmulateConfig: d.EmulateConfig, env: d.E2EProcessEnv): void;

package/dist/testing/puppeteer/puppeteer-events.d.ts

@@ -0,0 +1,21 @@
+import * as d from '../../declarations';
+import * as pd from './puppeteer-declarations';
+import * as puppeteer from 'puppeteer';
+export declare function initPageEvents(page: pd.E2EPageInternal): Promise<void>;
+export declare function waitForEvent(page: pd.E2EPageInternal, eventName: string, elementHandle: puppeteer.ElementHandle): Promise<any>;
+export declare class EventSpy implements d.EventSpy {
+    eventName: string;
+    events: d.SerializedEvent[];
+    private cursor;
+    private queuedHandler;
+    constructor(eventName: string);
+    get length(): number;
+    get firstEvent(): d.SerializedEvent;
+    get lastEvent(): d.SerializedEvent;
+    next(): Promise<{
+        done: boolean;
+        value: d.SerializedEvent;
+    }>;
+    push(ev: d.SerializedEvent): void;
+}
+export declare function addE2EListener(page: pd.E2EPageInternal, elmHandle: puppeteer.JSHandle, eventName: string, callback: (ev: any) => void): Promise<void>;

package/dist/testing/puppeteer/puppeteer-find.d.ts

@@ -0,0 +1,5 @@
+import * as pd from './puppeteer-declarations';
+import { E2EElement } from './puppeteer-element';
+import * as puppeteer from 'puppeteer';
+export declare function find(page: pd.E2EPageInternal, rootHandle: puppeteer.ElementHandle, selector: pd.FindSelector): Promise<E2EElement>;
+export declare function findAll(page: pd.E2EPageInternal, rootHandle: puppeteer.ElementHandle, selector: pd.FindSelector): Promise<E2EElement[]>;

package/dist/testing/puppeteer/puppeteer-page.d.ts

@@ -0,0 +1,2 @@
+import * as pd from './puppeteer-declarations';
+export declare function newE2EPage(opts?: pd.NewE2EPageOptions): Promise<pd.E2EPage>;

package/dist/testing/puppeteer/puppeteer-screenshot.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+import * as pd from './puppeteer-declarations';
+export declare function initPageScreenshot(page: pd.E2EPageInternal): void;
+export declare function pageCompareScreenshot(page: pd.E2EPageInternal, env: d.E2EProcessEnv, desc: string, testPath: string, opts: d.ScreenshotOptions): Promise<d.ScreenshotDiff>;

package/dist/testing/spec-page.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../declarations';
+export declare function newSpecPage(opts: d.NewSpecPageOptions): Promise<d.SpecPage>;
+export declare function flushAll(): any;
+export declare function flushQueue(): any;
+export declare function flushLoadModule(): any;

package/dist/testing/task-queue.d.ts

@@ -0,0 +1,15 @@
+import * as d from '../declarations';
+export declare const consoleError: (e: any) => void;
+export declare const consoleDevError: (...e: any[]) => void;
+export declare const consoleDevWarn: (..._: any[]) => void;
+export declare const consoleDevInfo: (..._: any[]) => void;
+export declare function resetTaskQueue(): void;
+export declare const nextTick: (cb: Function) => void;
+export declare function flushTicks(): Promise<unknown>;
+export declare function writeTask(cb: d.RafCallback): void;
+export declare function readTask(cb: d.RafCallback): void;
+export declare function flushQueue(): Promise<unknown>;
+export declare function flushAll(): Promise<unknown>;
+export declare function loadModule(cmpMeta: d.ComponentRuntimeMeta, _hostRef: d.HostRef, _hmrVersionId?: string): Promise<any>;
+export declare function flushLoadModule(bundleId?: string): Promise<unknown>;
+export declare function registerModule(bundleId: string, Cstr: any): void;

package/dist/testing/test-transpile.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../declarations';
+import ts from 'typescript';
+export declare function transpile(input: string, opts?: d.TransformOptions, sourceFilePath?: string): d.TranspileResults;
+export declare function getCompilerOptions(rootDir: string): ts.CompilerOptions;
+export declare function formatDiagnostic(diagnostic: d.Diagnostic): string;

package/dist/testing/testing-fs.d.ts

@@ -0,0 +1,31 @@
+import * as d from '../declarations';
+export declare class TestingFs implements d.FileSystem {
+    data: Map<string, Data>;
+    diskWrites: number;
+    diskReads: number;
+    access(itemPath: string): Promise<void>;
+    copyFile(srcPath: string, destPath: string): Promise<void>;
+    existsSync(filePath: string): boolean;
+    createReadStream(_filePath: string): any;
+    mkdir(dirPath: string): Promise<void>;
+    mkdirSync(dirPath: string): void;
+    readdir(dirPath: string): Promise<string[]>;
+    readdirSync(dirPath: string): string[];
+    readFile(filePath: string): Promise<string>;
+    readFileSync(filePath: string): string;
+    rmdir(dirPath: string): Promise<void>;
+    stat(itemPath: string): Promise<d.FsStats>;
+    statSync(itemPath: string): d.FsStats;
+    unlink(filePath: string): Promise<void>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    writeFileSync(filePath: string, content: string): void;
+    writeFiles(files: {
+        [filePath: string]: string;
+    }): Promise<void[]>;
+}
+interface Data {
+    isFile: boolean;
+    isDirectory: boolean;
+    content?: string;
+}
+export {};

package/dist/testing/testing-logger.d.ts

@@ -0,0 +1,23 @@
+import * as d from '../declarations';
+export declare class TestingLogger implements d.Logger {
+    enable: boolean;
+    level: string;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    debug(...msg: any[]): void;
+    color(_msg: string, _color: 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'gray'): void;
+    red(msg: string): string;
+    green(msg: string): string;
+    yellow(msg: string): string;
+    blue(msg: string): string;
+    magenta(msg: string): string;
+    cyan(msg: string): string;
+    gray(msg: string): string;
+    bold(msg: string): string;
+    dim(msg: string): string;
+    createTimeSpan(_startMsg: string, _debug?: boolean): d.LoggerTimeSpan;
+    printDiagnostics(_diagnostics: d.Diagnostic[]): void;
+    buildLogFilePath: string;
+    writeLogs(_: boolean): void;
+}

package/dist/testing/testing-sys.d.ts

@@ -0,0 +1,19 @@
+import { RindoSystem } from '../declarations';
+export declare const NodeSystem: NodeSystemSystemConstructor;
+export interface NodeSystemSystemConstructor {
+    new (fs: any): RindoSystem;
+}
+export declare class TestingSystem extends NodeSystem {
+    constructor();
+    get compiler(): {
+        name: string;
+        version: string;
+        typescriptVersion?: string;
+        runtime?: string;
+        packageDir?: string;
+        distDir?: string;
+    };
+    getClientPath(staticName: string): string;
+    getClientCoreFile(opts: any): Promise<string>;
+    tmpdir(): string;
+}

package/dist/testing/testing-utils.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../declarations';
+export declare function shuffleArray(array: any[]): any[];
+export declare function expectFiles(fs: d.InMemoryFileSystem, filePaths: string[]): void;
+export declare function doNotExpectFiles(fs: d.InMemoryFileSystem, filePaths: string[]): void;
+export declare function wroteFile(r: d.BuildResults, p: string): boolean;

package/dist/testing/testing.d.ts

@@ -0,0 +1,12 @@
+import * as d from '../declarations';
+import * as puppeteer from 'puppeteer';
+export declare class Testing implements d.Testing {
+    isValid: boolean;
+    compiler: d.Compiler;
+    config: d.Config;
+    devServer: d.DevServer;
+    puppeteerBrowser: puppeteer.Browser;
+    constructor(config: d.Config);
+    runTests(): Promise<boolean>;
+    destroy(): Promise<void>;
+}