@rindo/core 1.8.12

package/dist/testing/jest/jest-config.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+export declare function buildJestArgv(config: d.Config): d.JestArgv;
+export declare function buildJestConfig(config: d.Config): string;
+export declare function getProjectListFromCLIArgs(config: d.Config, argv: d.JestArgv): any;

package/dist/testing/jest/jest-environment.d.ts

@@ -0,0 +1,12 @@
+import * as d from '../../declarations';
+export declare function createJestPuppeteerEnvironment(): {
+    new (config: any): {
+        global: d.JestEnvironmentGlobal;
+        browser: any;
+        pages: any[];
+        setup(): Promise<void>;
+        newPuppeteerPage(): Promise<import("puppeteer").Page>;
+        closeOpenPages(): Promise<void>;
+        teardown(): Promise<void>;
+    };
+};

package/dist/testing/jest/jest-preprocessor.d.ts

@@ -0,0 +1,10 @@
+export declare const jestPreprocessor: {
+    process(sourceText: string, filePath: string, jestConfig: {
+        rootDir: string;
+    }): string;
+    getCompilerOptions(rootDir: string): any;
+    getCacheKey(code: string, filePath: string, jestConfigStr: string, transformOptions: {
+        instrument: boolean;
+        rootDir: string;
+    }): string;
+};

package/dist/testing/jest/jest-runner.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../../declarations';
+export declare function runJest(config: d.Config, env: d.E2EProcessEnv): Promise<boolean>;
+export declare function createTestRunner(): any;
+export declare function includeTestFile(testPath: string, env: d.E2EProcessEnv): boolean;
+export declare function getEmulateConfigs(testing: d.TestingConfig, flags: d.ConfigFlags): d.EmulateConfig[];

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

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function runJestScreenshot(config: d.Config, env: d.E2EProcessEnv): Promise<boolean>;

package/dist/testing/jest/jest-serializer.d.ts

@@ -0,0 +1,5 @@
+import { MockNode } from '@mock-doc';
+export declare const HtmlSerializer: {
+    print: (val: HTMLElement | MockNode) => string;
+    test: (val: any) => boolean;
+};

package/dist/testing/jest/jest-setup-test-framework.d.ts

@@ -0,0 +1 @@
+export declare function jestSetupTestFramework(): void;

package/dist/testing/matchers/attributes.d.ts

@@ -0,0 +1,14 @@
+export declare function toEqualAttribute(elm: HTMLElement, expectAttrName: string, expectAttrValue: string): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toEqualAttributes(elm: HTMLElement, expectAttrs: {
+    [attrName: string]: any;
+}): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toHaveAttribute(elm: HTMLElement, expectAttrName: string): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/matchers/class-list.d.ts

@@ -0,0 +1,12 @@
+export declare function toHaveClass(elm: HTMLElement, expectClassName: string): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toHaveClasses(elm: HTMLElement, expectClassNames: string[]): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toMatchClasses(elm: HTMLElement, expectClassNames: string[]): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/matchers/events.d.ts

@@ -0,0 +1,13 @@
+import * as d from '../../declarations';
+export declare function toHaveReceivedEvent(eventSpy: d.EventSpy): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toHaveReceivedEventTimes(eventSpy: d.EventSpy, count: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toHaveReceivedEventDetail(eventSpy: d.EventSpy, eventDetail: any): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/matchers/html.d.ts

@@ -0,0 +1,12 @@
+export declare function toEqualHtml(input: string | HTMLElement | ShadowRoot, shouldEqual: string): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toEqualLightHtml(input: string | HTMLElement | ShadowRoot, shouldEqual: string): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function compareHtml(input: string | HTMLElement | ShadowRoot, shouldEqual: string, serializeShadowRoot: boolean): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/matchers/index.d.ts

@@ -0,0 +1,21 @@
+import { toEqualAttribute, toEqualAttributes, toHaveAttribute } from './attributes';
+import { toHaveReceivedEvent, toHaveReceivedEventDetail, toHaveReceivedEventTimes } from './events';
+import { toEqualHtml, toEqualLightHtml } from './html';
+import { toEqualText } from './text';
+import { toHaveClass, toHaveClasses, toMatchClasses } from './class-list';
+import { toMatchScreenshot } from './screenshot';
+export declare const expectExtend: {
+    toEqualAttribute: typeof toEqualAttribute;
+    toEqualAttributes: typeof toEqualAttributes;
+    toEqualHtml: typeof toEqualHtml;
+    toEqualLightHtml: typeof toEqualLightHtml;
+    toEqualText: typeof toEqualText;
+    toHaveAttribute: typeof toHaveAttribute;
+    toHaveClass: typeof toHaveClass;
+    toHaveClasses: typeof toHaveClasses;
+    toMatchClasses: typeof toMatchClasses;
+    toHaveReceivedEvent: typeof toHaveReceivedEvent;
+    toHaveReceivedEventDetail: typeof toHaveReceivedEventDetail;
+    toHaveReceivedEventTimes: typeof toHaveReceivedEventTimes;
+    toMatchScreenshot: typeof toMatchScreenshot;
+};

package/dist/testing/matchers/screenshot.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../../declarations';
+export declare function toMatchScreenshot(compare: d.ScreenshotDiff, opts?: d.MatchScreenshotOptions): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/matchers/text.d.ts

@@ -0,0 +1,4 @@
+export declare function toEqualText(input: HTMLElement | string, expectTextContent: string): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/testing/mock-fetch.d.ts

@@ -0,0 +1,46 @@
+export declare function setupMockFetch(global: any): void;
+export declare function mockFetchReset(): void;
+export declare const mockFetch: {
+    json(data: any, url?: MockRequestInput): void;
+    text(data: string, url?: MockRequestInput): void;
+    response(rsp: MockResponse, url?: MockRequestInput): void;
+    reject(rsp?: MockResponse, url?: MockRequestInput): void;
+    reset: typeof mockFetchReset;
+};
+export declare class MockHeaders {
+    values: Map<string, string>;
+    constructor(values?: string[][]);
+    serialize(): string[][];
+    append(key: string, value: string): void;
+    delete(key: string): void;
+    get(key: string): string;
+    has(key: string): boolean;
+    set(key: string, value: string): void;
+}
+export interface MockRequest {
+    headers?: MockHeaders;
+    method?: string;
+    referrer?: string;
+    url?: string;
+}
+export interface MockResponse {
+    headers?: MockHeaders;
+    ok?: boolean;
+    status?: number;
+    statusText?: string;
+    type?: string;
+    url?: string;
+    json?(): Promise<any>;
+    text?(): Promise<string>;
+}
+export interface MockedResponseData {
+    input: MockRequestInput;
+    textStr: string;
+    jsonStr: string;
+    headers: string[][];
+    status: number;
+    statusText: string;
+    type: string;
+    reject: boolean;
+}
+export declare type MockRequestInput = MockRequest | string;

package/dist/testing/mocks.d.ts

@@ -0,0 +1,12 @@
+import * as d from '../declarations';
+import { TestingFs } from './testing-fs';
+import { TestingLogger } from './testing-logger';
+export declare function mockConfig(): d.Config;
+export declare function mockCompilerCtx(): d.CompilerCtx;
+export declare function mockBuildCtx(config?: d.Config, compilerCtx?: d.CompilerCtx): d.BuildCtx;
+export declare function mockFs(): TestingFs;
+export declare function mockCache(): d.Cache;
+export declare function mockLogger(): TestingLogger;
+export declare function mockRindoSystem(): d.RindoSystem;
+export declare function mockDocument(html?: string): Document;
+export declare function mockWindow(html?: string): Window;

package/dist/testing/platform.d.ts

@@ -0,0 +1,23 @@
+import * as d from '../declarations';
+export * from './task-queue';
+export declare const win: Window;
+export declare const doc: Document;
+export declare const styles: d.StyleMap;
+export declare const cssVarShim: d.CssVarShim;
+export declare const Build: d.UserBuildConditionals;
+export declare const plt: d.PlatformRuntime;
+export declare const supportsShadowDom = true;
+export declare const supportsListenerOptions = true;
+export declare const supportsConstructibleStylesheets = false;
+export declare function resetPlatform(): void;
+export declare function stopAutoApplyChanges(): void;
+export declare function startAutoApplyChanges(): Promise<void>;
+export declare function registerContext(context: any): void;
+export declare const getHostRef: (elm: d.RuntimeRef) => d.HostRef;
+export declare const registerInstance: (lazyInstance: any, hostRef: d.HostRef) => Map<d.RuntimeRef, d.HostRef>;
+export declare const registerHost: (elm: d.HostElement) => void;
+export declare const Context: any;
+export declare const registerComponents: (Cstrs: d.ComponentTestingConstructor[]) => void;
+export declare const isMemberInElement: (elm: any, memberName: string) => boolean;
+export declare const patchDynamicImport: (_: string) => void;
+export * from '@runtime';

package/dist/testing/platform.js

@@ -0,0 +1,321 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mockDoc = require('../mock-doc');
+var runtime = require('../runtime');
+
+const queuedTicks = [];
+const queuedWriteTasks = [];
+const queuedReadTasks = [];
+const moduleLoaded = new Map();
+const queuedLoadModules = [];
+const caughtErrors = [];
+const consoleError = (e) => {
+    caughtErrors.push(e);
+};
+const consoleDevError = (...e) => {
+    caughtErrors.push(new Error(e.join(', ')));
+};
+const consoleDevWarn = (..._) => { };
+const consoleDevInfo = (..._) => { };
+function resetTaskQueue() {
+    queuedTicks.length = 0;
+    queuedWriteTasks.length = 0;
+    queuedReadTasks.length = 0;
+    moduleLoaded.clear();
+    queuedLoadModules.length = 0;
+    caughtErrors.length = 0;
+}
+const nextTick = (cb) => {
+    queuedTicks.push(cb);
+};
+function flushTicks() {
+    return new Promise((resolve, reject) => {
+        function drain() {
+            try {
+                if (queuedTicks.length > 0) {
+                    const writeTasks = queuedTicks.slice();
+                    queuedTicks.length = 0;
+                    let cb;
+                    while ((cb = writeTasks.shift())) {
+                        cb(Date.now());
+                    }
+                }
+                if (queuedTicks.length > 0) {
+                    process.nextTick(drain);
+                }
+                else {
+                    resolve();
+                }
+            }
+            catch (e) {
+                reject(`flushTicks: ${e}`);
+            }
+        }
+        process.nextTick(drain);
+    });
+}
+function writeTask(cb) {
+    queuedWriteTasks.push(cb);
+}
+function readTask(cb) {
+    queuedReadTasks.push(cb);
+}
+function flushQueue() {
+    return new Promise((resolve, reject) => {
+        async function drain() {
+            try {
+                if (queuedReadTasks.length > 0) {
+                    const readTasks = queuedReadTasks.slice();
+                    queuedReadTasks.length = 0;
+                    let cb;
+                    while ((cb = readTasks.shift())) {
+                        const result = cb(Date.now());
+                        if (result != null && typeof result.then === 'function') {
+                            await result;
+                        }
+                    }
+                }
+                if (queuedWriteTasks.length > 0) {
+                    const writeTasks = queuedWriteTasks.slice();
+                    queuedWriteTasks.length = 0;
+                    let cb;
+                    while ((cb = writeTasks.shift())) {
+                        const result = cb(Date.now());
+                        if (result != null && typeof result.then === 'function') {
+                            await result;
+                        }
+                    }
+                }
+                if ((queuedReadTasks.length + queuedWriteTasks.length) > 0) {
+                    process.nextTick(drain);
+                }
+                else {
+                    resolve();
+                }
+            }
+            catch (e) {
+                reject(`flushQueue: ${e}`);
+            }
+        }
+        process.nextTick(drain);
+    });
+}
+async function flushAll() {
+    while ((queuedTicks.length +
+        queuedLoadModules.length +
+        queuedWriteTasks.length +
+        queuedReadTasks.length) > 0) {
+        await flushTicks();
+        await flushLoadModule();
+        await flushQueue();
+    }
+    if (caughtErrors.length > 0) {
+        const err = caughtErrors[0];
+        if (err == null) {
+            throw new Error('Error!');
+        }
+        if (typeof err === 'string') {
+            throw new Error(err);
+        }
+        throw err;
+    }
+    return new Promise(resolve => process.nextTick(resolve));
+}
+function loadModule(cmpMeta, _hostRef, _hmrVersionId) {
+    return new Promise(resolve => {
+        queuedLoadModules.push({
+            bundleId: cmpMeta.$lazyBundleIds$,
+            resolve: () => resolve(moduleLoaded.get(cmpMeta.$lazyBundleIds$))
+        });
+    });
+}
+function flushLoadModule(bundleId) {
+    return new Promise((resolve, reject) => {
+        try {
+            process.nextTick(() => {
+                if (bundleId != null) {
+                    for (let i = 0; i < queuedLoadModules.length; i++) {
+                        if (queuedLoadModules[i].bundleId === bundleId) {
+                            queuedLoadModules[i].resolve();
+                            queuedLoadModules.splice(i, 1);
+                            i--;
+                        }
+                    }
+                }
+                else {
+                    let queuedLoadModule;
+                    while ((queuedLoadModule = queuedLoadModules.shift())) {
+                        queuedLoadModule.resolve();
+                    }
+                }
+                resolve();
+            });
+        }
+        catch (e) {
+            reject(`flushLoadModule: ${e}`);
+        }
+    });
+}
+function registerModule(bundleId, Cstr) {
+    moduleLoaded.set(bundleId, Cstr);
+}
+
+const win = mockDoc.setupGlobal(global);
+const doc = win.document;
+const hostRefs = new Map();
+const styles = new Map();
+const cssVarShim = false;
+const Build = {
+    isDev: true,
+    isBrowser: false
+};
+const plt = {
+    $flags$: 0,
+    $resourcesUrl$: '',
+    jmp: (h) => h(),
+    raf: (h) => requestAnimationFrame(h),
+    ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
+    rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
+};
+const supportsShadowDom = true;
+const supportsListenerOptions = true;
+const supportsConstructibleStylesheets = false;
+let isAutoApplyingChanges = false;
+let autoApplyTimer = undefined;
+function resetPlatform() {
+    if (win && typeof win.close === 'function') {
+        win.close();
+    }
+    hostRefs.clear();
+    styles.clear();
+    plt.$flags$ = 0;
+    Object.keys(Context).forEach(key => delete Context[key]);
+    if (plt.$orgLocNodes$ != null) {
+        plt.$orgLocNodes$.clear();
+        plt.$orgLocNodes$ = undefined;
+    }
+    win.location.href = plt.$resourcesUrl$ = `http://testing-rindojs.web.app/`;
+    resetTaskQueue();
+    stopAutoApplyChanges();
+    cstrs.clear();
+}
+function stopAutoApplyChanges() {
+    isAutoApplyingChanges = false;
+    if (autoApplyTimer) {
+        clearTimeout(autoApplyTimer);
+        autoApplyTimer = undefined;
+    }
+}
+async function startAutoApplyChanges() {
+    isAutoApplyingChanges = true;
+    flushAll().then(() => {
+        if (isAutoApplyingChanges) {
+            autoApplyTimer = setTimeout(() => {
+                startAutoApplyChanges();
+            }, 100);
+        }
+    });
+}
+function registerContext(context) {
+    if (context) {
+        Object.assign(Context, context);
+    }
+}
+const getHostRef = (elm) => {
+    return hostRefs.get(elm);
+};
+const registerInstance = (lazyInstance, hostRef) => {
+    if (lazyInstance == null || lazyInstance.constructor == null) {
+        throw new Error(`Invalid component constructor`);
+    }
+    if (hostRef == null) {
+        const Cstr = lazyInstance.constructor;
+        const tagName = (Cstr.COMPILER_META && Cstr.COMPILER_META.tagName) ? Cstr.COMPILER_META.tagName : 'div';
+        const elm = document.createElement(tagName);
+        registerHost(elm);
+        hostRef = getHostRef(elm);
+    }
+    hostRef.$lazyInstance$ = lazyInstance;
+    return hostRefs.set(lazyInstance, hostRef);
+};
+const registerHost = (elm) => {
+    const hostRef = {
+        $flags$: 0,
+        $hostElement$: elm,
+        $instanceValues$: new Map(),
+        $renderCount$: 0
+    };
+    hostRef.$onInstancePromise$ = new Promise(r => hostRef.$onInstanceResolve$ = r);
+    hostRef.$onReadyPromise$ = new Promise(r => hostRef.$onReadyResolve$ = r);
+    elm['s-p'] = [];
+    elm['s-rc'] = [];
+    hostRefs.set(elm, hostRef);
+};
+const Context = {};
+const cstrs = new Map();
+const registerComponents = (Cstrs) => {
+    Cstrs.forEach(Cstr => {
+        cstrs.set(Cstr.COMPILER_META.tagName, Cstr);
+    });
+};
+const isMemberInElement = (elm, memberName) => {
+    if (elm != null) {
+        if (memberName in elm) {
+            return true;
+        }
+        const nodeName = elm.nodeName;
+        if (nodeName) {
+            const cstr = cstrs.get(nodeName.toLowerCase());
+            if (cstr != null && cstr.COMPILER_META != null && cstr.COMPILER_META.properties != null) {
+                return cstr.COMPILER_META.properties.some(p => p.name === memberName);
+            }
+        }
+    }
+    return false;
+};
+const patchDynamicImport = (_) => { return; };
+
+Object.keys(runtime).forEach(function (k) {
+    if (k !== 'default') Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () {
+            return runtime[k];
+        }
+    });
+});
+exports.Build = Build;
+exports.Context = Context;
+exports.consoleDevError = consoleDevError;
+exports.consoleDevInfo = consoleDevInfo;
+exports.consoleDevWarn = consoleDevWarn;
+exports.consoleError = consoleError;
+exports.cssVarShim = cssVarShim;
+exports.doc = doc;
+exports.flushAll = flushAll;
+exports.flushLoadModule = flushLoadModule;
+exports.flushQueue = flushQueue;
+exports.flushTicks = flushTicks;
+exports.getHostRef = getHostRef;
+exports.isMemberInElement = isMemberInElement;
+exports.loadModule = loadModule;
+exports.nextTick = nextTick;
+exports.patchDynamicImport = patchDynamicImport;
+exports.plt = plt;
+exports.readTask = readTask;
+exports.registerComponents = registerComponents;
+exports.registerContext = registerContext;
+exports.registerHost = registerHost;
+exports.registerInstance = registerInstance;
+exports.registerModule = registerModule;
+exports.resetPlatform = resetPlatform;
+exports.resetTaskQueue = resetTaskQueue;
+exports.startAutoApplyChanges = startAutoApplyChanges;
+exports.stopAutoApplyChanges = stopAutoApplyChanges;
+exports.styles = styles;
+exports.supportsConstructibleStylesheets = supportsConstructibleStylesheets;
+exports.supportsListenerOptions = supportsListenerOptions;
+exports.supportsShadowDom = supportsShadowDom;
+exports.win = win;
+exports.writeTask = writeTask;

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

@@ -0,0 +1,6 @@
+import * as d from '../../declarations';
+import * as puppeteer from 'puppeteer';
+export declare function startPuppeteerBrowser(config: d.Config): Promise<any>;
+export declare function connectBrowser(): Promise<any>;
+export declare function disconnectBrowser(browser: puppeteer.Browser): Promise<void>;
+export declare function newBrowserPage(browser: puppeteer.Browser): Promise<puppeteer.Page>;