@rindo/core 2.16.1 → 2.17.1

package/sys/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/sys/node",
-  "version": "2.16.1",
+  "version": "2.17.1",
   "description": "Rindo Node System.",
   "main": "./index.js",
   "types": "./index.d.ts",

package/sys/node/worker.js

@@ -1,5 +1,5 @@
 /*!
- Rindo Node System Worker v2.16.1 | MIT Licensed | https://rindojs.web.app
+ Rindo Node System Worker v2.17.1 | MIT Licensed | https://rindojs.web.app
  */
 function _interopNamespace(e) {
  if (e && e.__esModule) return e;

package/testing/index.d.ts

@@ -3,7 +3,7 @@ export { createTesting } from './testing';
 export { createTestRunner } from './jest/jest-runner';
 export { jestPreprocessor } from './jest/jest-preprocessor';
 export { jestSetupTestFramework } from './jest/jest-setup-test-framework';
-export { mockBuildCtx, mockConfig, mockCompilerCtx, mockDocument, mockLogger, mockRindoSystem, mockWindow, } from './mocks';
+export { mockBuildCtx, mockConfig, mockCompilerCtx, mockDocument, mockLoadConfigInit, mockValidatedConfig, mockLogger, mockCompilerSystem, mockWindow, mockModule, } from './mocks';
 export { MockHeaders, MockRequest, MockRequestInit, MockRequestInfo, MockResponse, MockResponseInit, mockFetch, } from './mock-fetch';
 export { newSpecPage } from './spec-page';
 export { shuffleArray } from './testing-utils';

package/testing/index.js

@@ -1,5 +1,5 @@
 /*!
- Rindo Testing v2.16.1 | MIT Licensed | https://rindojs.web.app
+ Rindo Testing v2.17.1 | MIT Licensed | https://rindojs.web.app
  */
 function _lazyRequire(e) {
  return new Proxy({}, {
@@ -476,7 +476,11 @@ function mockConfig(e) {
   nodeResolve: {
    customResolveOptions: {}
   },
-  sourceMap: !0
+  sourceMap: !0,
+  rollupPlugins: {
+   before: [],
+   after: []
+  }
  };
 }
 
@@ -499,7 +503,7 @@ function mockCompilerCtx(e) {
   compilerOptions: null,
   cache: null,
   cssModuleImports: new Map,
-  events: null,
+  events: buildEvents(),
   fs: null,
   hasSuccessfulBuild: !1,
   isActivelyBuilding: !1,
@@ -813,6 +817,10 @@ function mockCompilerCtx(e) {
  }), t;
 }
 
+function mockLogger() {
+ return new TestingLogger;
+}
+
 function findRootComponent(e, t) {
  if (null != t) {
   const r = t.children, s = r.length;
@@ -2087,7 +2095,46 @@ const MAX_FAILED = 100, ONE_DAY = 864e5, ONE_WEEK = 7 * ONE_DAY, EXP_STORAGE_KEY
  posix: null
 }).posix = posix, pathBrowserify = posix;
 
-const IS_NODE_ENV = !("undefined" == typeof global || "function" != typeof require || !global.process || "string" != typeof __filename || global.origin && "string" == typeof global.origin);
+const buildEvents = () => {
+ const e = [], t = t => {
+  const r = e.findIndex((e => e.callback === t));
+  return r > -1 && (e.splice(r, 1), !0);
+ };
+ return {
+  emit: (t, r) => {
+   const s = t.toLowerCase().trim(), n = e.slice();
+   for (const e of n) if (null == e.eventName) try {
+    e.callback(t, r);
+   } catch (e) {
+    console.error(e);
+   } else if (e.eventName === s) try {
+    e.callback(r);
+   } catch (e) {
+    console.error(e);
+   }
+  },
+  on: (r, s) => {
+   if ("function" == typeof r) {
+    const s = null, n = r;
+    return e.push({
+     eventName: s,
+     callback: n
+    }), () => t(n);
+   }
+   if ("string" == typeof r && "function" == typeof s) {
+    const n = r.toLowerCase().trim(), o = s;
+    return e.push({
+     eventName: n,
+     callback: o
+    }), () => t(o);
+   }
+   return () => !1;
+  },
+  unsubscribeAll: () => {
+   e.length = 0;
+  }
+ };
+}, IS_NODE_ENV = !("undefined" == typeof global || "function" != typeof require || !global.process || "string" != typeof __filename || global.origin && "string" == typeof global.origin);
 
 IS_NODE_ENV && process.platform;
 
@@ -2119,15 +2166,14 @@ const YELLOW = "#f39c12", RED = "#c0392b", BLUE = "#3498db", COMMON_DIR_MODULE_E
  let o = s.shift();
  o.startsWith("@") && (o += "/" + s.shift());
  const i = s.join("/");
- if ("@rindo/core" === o) {
-  return ((e, t) => {
-   let r = (t = normalizePath(t)).split("/");
-   const s = r.lastIndexOf("node_modules");
-   return s > -1 && s < r.length - 1 && (r = r.slice(s + 1), r = r[0].startsWith("@") ? r.slice(2) : r.slice(1), 
-   t = r.join("/")), new URL("./" + t, (e => new URL("../", e).href)(e)).href;
-  })(e.getCompilerExecutingPath(), i);
- }
- return e.getRemoteModuleUrl({
+ return "@rindo/core" === o ? ((e, t) => {
+  let r = (t = normalizePath(t)).split("/");
+  const s = r.lastIndexOf("node_modules");
+  s > -1 && s < r.length - 1 && (r = r.slice(s + 1), r = r[0].startsWith("@") ? r.slice(2) : r.slice(1), 
+  t = r.join("/"));
+  const n = new URL("../", e).href;
+  return new URL("./" + t, n).href;
+ })(e.getCompilerExecutingPath(), i) : e.getRemoteModuleUrl({
   moduleId: o,
   version: t.get(o),
   path: i
@@ -2139,7 +2185,7 @@ const YELLOW = "#f39c12", RED = "#c0392b", BLUE = "#3498db", COMMON_DIR_MODULE_E
   const r = e.split("/"), s = r[r.length - 2], n = r[r.length - 1];
   return !("node_modules" !== s || !isCommonDirModuleFile(n));
  })(n) || known404Urls.has(s) || (e => knownUrlSkips.some((t => e.endsWith(t))))(s))) try {
-  const o = await ((e, t, r) => (console.trace(t), e && isFunction(e.fetch) ? e.fetch(t, r) : fetch(t, r)))(e, s);
+  const o = await ((e, t, r) => e && isFunction(e.fetch) ? e.fetch(t, r) : fetch(t, r))(e, s);
   if (o) {
    if (o.ok) {
     const i = await o.clone().text();
@@ -2852,46 +2898,7 @@ const createSystem = e => {
     })(t, e)));
    }
   };
- })(), r = new Map, s = new Set, n = e => s.add(e), o = e => s.delete(e), i = (() => {
-  const e = [], t = t => {
-   const r = e.findIndex((e => e.callback === t));
-   return r > -1 && (e.splice(r, 1), !0);
-  };
-  return {
-   emit: (t, r) => {
-    const s = t.toLowerCase().trim(), n = e.slice();
-    for (const e of n) if (null == e.eventName) try {
-     e.callback(t, r);
-    } catch (e) {
-     console.error(e);
-    } else if (e.eventName === s) try {
-     e.callback(r);
-    } catch (e) {
-     console.error(e);
-    }
-   },
-   on: (r, s) => {
-    if ("function" == typeof r) {
-     const s = null, n = r;
-     return e.push({
-      eventName: s,
-      callback: n
-     }), () => t(n);
-    }
-    if ("string" == typeof r && "function" == typeof s) {
-     const n = r.toLowerCase().trim(), o = s;
-     return e.push({
-      eventName: n,
-      callback: o
-     }), () => t(o);
-    }
-    return () => !1;
-   },
-   unsubscribeAll: () => {
-    e.length = 0;
-   }
-  };
- })(), a = IS_BROWSER_ENV && navigator.hardwareConcurrency || 1, l = e => {
+ })(), r = new Map, s = new Set, n = e => s.add(e), o = e => s.delete(e), i = buildEvents(), a = IS_BROWSER_ENV && navigator.hardwareConcurrency || 1, l = e => {
   if ("/" === e || "" === e) return "/";
   const t = path$2.dirname(e), r = path$2.basename(e);
   return t.endsWith("/") ? normalizePath(`${t}${r}`) : normalizePath(`${t}/${r}`);
@@ -3037,7 +3044,7 @@ const createSystem = e => {
  u("/");
  const D = {
   name: "in-memory",
-  version: "2.16.1",
+  version: "2.17.1",
   events: i,
   access: async e => c(e),
   accessSync: c,
@@ -3325,7 +3332,8 @@ const createSystem = e => {
  r.readDirSync = s(r.readDirSync), r.stat = s(r.stat), r.statSync = s(r.statSync), 
  r.copyFile = n(r.copyFile), r.createDir = n(r.createDir), r.createDirSync = n(r.createDirSync), 
  r.removeFile = n(r.removeFile), r.removeFileSync = n(r.removeFileSync), r.writeFile = n(r.writeFile), 
- r.writeFileSync = n(r.writeFileSync), Object.defineProperties(r, {
+ r.writeFileSync = n(r.writeFileSync), r.getCompilerExecutingPath = () => "bin/rindo.js", 
+ Object.defineProperties(r, {
   diskReads: {
    get: () => e,
    set(t) {
@@ -3793,8 +3801,8 @@ exports.createJestPuppeteerEnvironment = function createJestPuppeteerEnvironment
 }, exports.createTesting = async e => {
  e = function t(e) {
   return e.buildEs5 = !1, e.devMode = !0, e.minifyCss = !1, e.minifyJs = !1, e.hashFileNames = !1, 
-  e.validateTypes = !1, e._isTesting = !0, e.buildDist = !0, e.flags = e.flags || {}, 
-  e.flags.serve = !1, e.flags.open = !1, e.outputTargets.forEach((e => {
+  e.validateTypes = !1, e._isTesting = !0, e.buildDist = !0, e.flags.serve = !1, e.flags.open = !1, 
+  e.outputTargets.forEach((e => {
    "www" === e.type && (e.serviceWorker = null);
   })), e.flags.args.includes("--watchAll") && (e.watch = !0), e;
  }(e);
@@ -3928,12 +3936,57 @@ exports.createJestPuppeteerEnvironment = function createJestPuppeteerEnvironment
  }
 }, exports.mockBuildCtx = function mockBuildCtx(e, t) {
  return e || (e = mockConfig()), t || (t = mockCompilerCtx(e)), new BuildContext(e, t);
-}, exports.mockCompilerCtx = mockCompilerCtx, exports.mockConfig = mockConfig, exports.mockDocument = function mockDocument(e = null) {
- return new index_cjs.MockWindow(e).document;
-}, exports.mockFetch = mockFetch, exports.mockLogger = function mockLogger() {
- return new TestingLogger;
-}, exports.mockRindoSystem = function mockRindoSystem() {
+}, exports.mockCompilerCtx = mockCompilerCtx, exports.mockCompilerSystem = function mockCompilerSystem() {
  return createTestingSystem();
+}, exports.mockConfig = mockConfig, exports.mockDocument = function mockDocument(e = null) {
+ return new index_cjs.MockWindow(e).document;
+}, exports.mockFetch = mockFetch, exports.mockLoadConfigInit = e => ({
+ config: {},
+ configPath: void 0,
+ initTsConfig: !0,
+ logger: void 0,
+ sys: void 0,
+ ...e
+}), exports.mockLogger = mockLogger, exports.mockModule = (e = {}) => ({
+ cmps: [],
+ coreRuntimeApis: [],
+ collectionName: "",
+ dtsFilePath: "",
+ excludeFromCollection: !1,
+ externalImports: [],
+ htmlAttrNames: [],
+ htmlTagNames: [],
+ htmlParts: [],
+ isCollectionDependency: !1,
+ isLegacy: !1,
+ jsFilePath: "",
+ localImports: [],
+ originalImports: [],
+ originalCollectionComponentPath: "",
+ potentialCmpRefs: [],
+ sourceFilePath: "",
+ staticSourceFile: "",
+ staticSourceFileText: "",
+ sourceMapPath: "",
+ sourceMapFileText: "",
+ hasVdomAttribute: !1,
+ hasVdomClass: !1,
+ hasVdomFunctional: !1,
+ hasVdomKey: !1,
+ hasVdomListener: !1,
+ hasVdomPropOrAttr: !1,
+ hasVdomRef: !1,
+ hasVdomRender: !1,
+ hasVdomStyle: !1,
+ hasVdomText: !1,
+ hasVdomXlink: !1,
+ ...e
+}), exports.mockValidatedConfig = function mockValidatedConfig(e) {
+ return {
+  ...mockConfig(e),
+  flags: {},
+  logger: mockLogger()
+ };
 }, exports.mockWindow = function mockWindow(e = null) {
  return new index_cjs.MockWindow(e);
 }, exports.newE2EPage = async function newE2EPage(e = {}) {
@@ -4037,26 +4090,28 @@ exports.createJestPuppeteerEnvironment = function createJestPuppeteerEnvironment
   };
   const o = !0 === e.failOnConsoleError, i = !0 === e.failOnNetworkError;
   t.on("console", (e => {
-   "error" === e.type() && (r.push({
+   if ("error" === e.type() && (r.push({
     type: "error",
     message: e.text(),
     location: e.location().url
-   }), o && fail(new Error(serializeConsoleMessage(e)))), function t(e) {
+   }), o)) throw new Error(serializeConsoleMessage(e));
+   !function t(e) {
     const t = serializeConsoleMessage(e), r = e.type(), s = "warning" === r ? "warn" : r;
     "debug" !== s && ("function" == typeof console[s] ? console[s](t) : console.log(r, t));
    }(e);
   })), t.on("pageerror", (e => {
-   r.push({
+   throw r.push({
     type: "pageerror",
     message: e.message,
     location: e.stack
-   }), fail(e);
+   }), e;
   })), t.on("requestfailed", (e => {
-   r.push({
+   if (r.push({
     type: "requestfailed",
     message: e.failure().errorText,
     location: e.url()
-   }), i ? fail(new Error(e.failure().errorText)) : console.error("requestfailed", e.url());
+   }), i) throw new Error(e.failure().errorText);
+   console.error("requestfailed", e.url());
   })), "string" == typeof e.html ? await e2eSetContent(t, e.html, {
    waitUntil: e.waitUntil
   }) : "string" == typeof e.url ? await e2eGoTo(t, e.url, {

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

@@ -5,7 +5,7 @@ import type { Config } from '@jest/types';
  * @param config the Rindo config to use while generating Jest CLI arguments
  * @returns the arguments to pass to the Jest CLI, wrapped in an object
  */
-export declare function buildJestArgv(config: d.Config): Config.Argv;
+export declare function buildJestArgv(config: d.ValidatedConfig): Config.Argv;
 /**
  * Generate a Jest run configuration to be used as a part of the `argv` passed to the Jest CLI when it is invoked
  * programmatically

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

@@ -1,9 +1,10 @@
 import type * as d from '@rindo/core/internal';
-export declare function runJest(config: d.Config, env: d.E2EProcessEnv): Promise<boolean>;
+import type { ConfigFlags } from '../../cli/config-flags';
+export declare function runJest(config: d.ValidatedConfig, env: d.E2EProcessEnv): Promise<boolean>;
 /**
  * Creates a Rindo test runner
  * @returns the test runner
  */
 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[];
+export declare function getEmulateConfigs(testing: d.TestingConfig, flags: ConfigFlags): d.EmulateConfig[];

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

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

package/testing/mocks.d.ts

@@ -1,10 +1,55 @@
-import type { BuildCtx, Cache, CompilerCtx, CompilerSystem, Config } from '@rindo/core/internal';
+import type { BuildCtx, Cache, CompilerCtx, CompilerSystem, Config, LoadConfigInit, ValidatedConfig, Module, UnvalidatedConfig } from '@rindo/core/internal';
+import { TestingSystem } from './testing-sys';
 import { TestingLogger } from './testing-logger';
-export declare function mockConfig(sys?: CompilerSystem): Config;
+/**
+ * Creates a mock instance of an internal, validated Rindo configuration object
+ * @param sys an optional compiler system to associate with the config. If one is not provided, one will be created for
+ * the caller
+ * @returns the mock Rindo configuration
+ */
+export declare function mockValidatedConfig(sys?: CompilerSystem): ValidatedConfig;
+/**
+ * Creates a mock instance of a Rindo configuration entity. The mocked configuration has no guarantees around the
+ * types/validity of its data.
+ * @param sys an optional compiler system to associate with the config. If one is not provided, one will be created for
+ * the caller
+ * @returns the mock Rindo configuration
+ */
+export declare function mockConfig(sys?: CompilerSystem): UnvalidatedConfig;
+/**
+ * Creates a configuration object used to bootstrap a Rindo task invocation
+ *
+ * Several fields are intentionally undefined for this entity. While it would be trivial to stub them out, this mock
+ * generation function operates under the assumption that entities like loggers and compiler system abstractions will
+ * be shared by multiple entities in a test suite, who should provide those entities to this function
+ *
+ * @param overrides the properties on the default entity to manually override
+ * @returns the default configuration initialization object, with any overrides applied
+ */
+export declare const mockLoadConfigInit: (overrides?: Partial<LoadConfigInit>) => LoadConfigInit;
 export declare function mockCompilerCtx(config?: Config): CompilerCtx;
 export declare function mockBuildCtx(config?: Config, compilerCtx?: CompilerCtx): BuildCtx;
 export declare function mockCache(config?: Config, compilerCtx?: CompilerCtx): Cache;
 export declare function mockLogger(): TestingLogger;
-export declare function mockRindoSystem(): CompilerSystem;
+/**
+ * Create a {@link CompilerSystem} entity for testing the compiler.
+ *
+ * This function acts as a thin wrapper around a {@link TestingSystem} entity creation. It exists to provide a logical
+ * place in the codebase where we might expect Rindo engineers to reach for when attempting to mock a
+ * {@link CompilerSystem} base type. Should there prove to be usage of both this function and the one it wraps,
+ * reconsider if this wrapper is necessary.
+ *
+ * @returns a System instance for testing purposes.
+ */
+export declare function mockCompilerSystem(): TestingSystem;
 export declare function mockDocument(html?: string): Document;
 export declare function mockWindow(html?: string): Window;
+/**
+ * This gives you a mock Module, an interface which is the internal compiler
+ * representation of a module. It includes a bunch of information necessary for
+ * compilation, this mock basically sets sane defaults for all those values.
+ *
+ * @param mod is an override module that you can supply to set particular values
+ * @returns a module object ready to use in tests!
+ */
+export declare const mockModule: (mod?: Partial<Module>) => Module;

package/testing/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/testing",
-  "version": "2.16.1",
+  "version": "2.17.1",
   "description": "Rindo testing suite.",
   "main": "./index.js",
   "types": "./index.d.ts",

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

@@ -1,6 +1,6 @@
-import type { Config } from '@rindo/core/internal';
+import type { ValidatedConfig } from '@rindo/core/internal';
 import type * as puppeteer from 'puppeteer';
-export declare function startPuppeteerBrowser(config: Config): Promise<puppeteer.Browser>;
+export declare function startPuppeteerBrowser(config: ValidatedConfig): Promise<puppeteer.Browser>;
 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>;

package/testing/testing-utils.d.ts

@@ -1,6 +1,78 @@
+/// <reference types="jest" />
 import type * as d from '@rindo/core/internal';
 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;
+/**
+ * Testing utility to validate the existence of some provided file paths using a specific file system
+ *
+ * @param fs the file system to use to validate the existence of some files
+ * @param filePaths the paths to validate
+ * @throws when one or more of the provided file paths cannot be found
+ */
+export declare function expectFilesExist(fs: d.InMemoryFileSystem, filePaths: string[]): void;
+/**
+ * Testing utility to validate the non-existence of some provided file paths using a specific file system
+ *
+ * @param fs the file system to use to validate the non-existence of some files
+ * @param filePaths the paths to validate
+ * @throws when one or more of the provided file paths is found
+ */
+export declare function expectFilesDoNotExist(fs: d.InMemoryFileSystem, filePaths: string[]): void;
 export declare function getAppScriptUrl(config: d.Config, browserUrl: string): string;
 export declare function getAppStyleUrl(config: d.Config, browserUrl: string): string;
+/**
+ * Utility for silencing `console` functions in tests.
+ *
+ * When this function is first called it grabs a reference to the `log`,
+ * `error`, and `warn` functions on `console` and then returns a per-test setup
+ * function which sets up a fresh set of mocks (via `jest.fn()`) and then
+ * assigns them to each of these functions. This setup function will return a
+ * reference to each of the three mock functions so tests can make assertions
+ * about their calls and so on.
+ *
+ * Because references to the original `.log`, `.error`, and `.warn` functions
+ * exist in closure within the function, it can use an `afterAll` call to clean
+ * up after itself and ensure that the original implementations are restored
+ * after the test suite finishes.
+ *
+ * An example of using this to silence log statements in a single test could look
+ * like this:
+ *
+ * ```ts
+ * describe("my-test-suite", () => {
+ *   const setupConsoleMocks = setupConsoleMocker()
+ *
+ *   it("should log a message", () => {
+ *     const { logMock } = setupConsoleMocks();
+ *     myFunctionWhichLogs(foo, bar);
+ *     expect(logMock).toBeCalledWith('my log message');
+ *   })
+ * })
+ * ```
+ *
+ * @returns a per-test mock setup function
+ */
+export declare function setupConsoleMocker(): ConsoleMocker;
+interface ConsoleMocker {
+    (): {
+        logMock: jest.Mock<typeof console.log>;
+        warnMock: jest.Mock<typeof console.warn>;
+        errorMock: jest.Mock<typeof console.error>;
+    };
+}
+/**
+ * the callback that `withSilentWarn` expects to receive. Basically receives a mock
+ * as its argument and returns a `Promise`, the value of which is returns by `withSilentWarn`
+ * as well.
+ */
+declare type SilentWarnFunc<T> = (mock: jest.Mock<typeof console.warn>) => Promise<T>;
+/**
+ * Wrap a single callback with a silent `console.warn`. The callback passed in
+ * receives the mocking function as an argument, so you can easily make assertions
+ * that it is called if necessary.
+ *
+ * @param cb a callback which `withSilentWarn` will call after replacing `console.warn`
+ * with a mock.
+ * @returns a Promise wrapping the return value of the callback
+ */
+export declare function withSilentWarn<T>(cb: SilentWarnFunc<T>): Promise<T>;
+export {};

package/testing/testing.d.ts

@@ -1,2 +1,2 @@
-import type { Config, Testing } from '@rindo/core/internal';
-export declare const createTesting: (config: Config) => Promise<Testing>;
+import type { ValidatedConfig, Testing } from '@rindo/core/internal';
+export declare const createTesting: (config: ValidatedConfig) => Promise<Testing>;