@stencil/core 4.43.3 → 5.0.0-alpha.1

package/dist/sys/node/index.d.mts

@@ -0,0 +1,32 @@
+import { gr as CompilerSystem, ri as Logger } from "../../index-D-LlB2nw.mjs";
+
+//#region src/sys/node/logger/index.d.ts
+/**
+ * Create a logger to run in a Node environment
+ *
+ * @returns the created logger
+ */
+declare const createNodeLogger: () => Logger;
+//#endregion
+//#region src/sys/node/node-setup-process.d.ts
+declare function setupNodeProcess(c: {
+  process: any;
+  logger: Logger;
+}): void;
+//#endregion
+//#region src/sys/node/node-sys.d.ts
+/**
+ * Create a node.js-specific {@link CompilerSystem} to be used when Stencil is
+ * run from the CLI or via the public API in a node context.
+ *
+ * This takes an optional param supplying a `process` object to be used.
+ *
+ * @param c an optional object wrapping `process` and `logger` objects
+ * @returns a node.js `CompilerSystem` object
+ */
+declare function createNodeSys(c?: {
+  process?: any;
+  logger?: Logger;
+}): CompilerSystem;
+//#endregion
+export { createNodeLogger, createNodeSys, setupNodeProcess };

package/dist/sys/node/index.mjs

@@ -0,0 +1,2 @@
+import { n as setupNodeProcess, r as createNodeLogger, t as createNodeSys } from "../../node-SxQIOCZE.mjs";
+export { createNodeLogger, createNodeSys, setupNodeProcess };

package/dist/sys/node/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/sys/node/worker.mjs

@@ -0,0 +1,48 @@
+import { l as createWorkerMessageHandler } from "../../compiler-LX4_RKKd.mjs";
+import { t as createNodeSys } from "../../node-SxQIOCZE.mjs";
+//#region src/sys/node/node-worker-thread.ts
+/**
+* Initialize a worker thread, setting up various machinery for managing
+* communication between the child process (worker) and the main thread.
+*
+* @param process a NodeJS process
+* @param msgHandler a worker message handler, which processes incoming
+* messages
+*/
+const initNodeWorkerThread = (process, msgHandler) => {
+	const sendHandle = (err) => {
+		if (err && err.code === "ERR_IPC_CHANNEL_CLOSED") process.exit(0);
+	};
+	const errorHandler = (stencilMsgId, err) => {
+		const errMsgBackToMain = {
+			stencilId: stencilMsgId,
+			stencilRtnValue: null,
+			stencilRtnError: "Error"
+		};
+		if (typeof err === "string") errMsgBackToMain.stencilRtnError += ": " + err;
+		else if (err) {
+			if (err.stack) errMsgBackToMain.stencilRtnError += ": " + err.stack;
+			else if (err.message) errMsgBackToMain.stencilRtnError += ":" + err.message;
+		}
+		process.send(errMsgBackToMain, sendHandle);
+	};
+	process.on("message", async (msgToWorker) => {
+		if (msgToWorker && typeof msgToWorker.stencilId === "number") try {
+			const msgFromWorker = {
+				stencilId: msgToWorker.stencilId,
+				stencilRtnValue: await msgHandler(msgToWorker),
+				stencilRtnError: null
+			};
+			process.send(msgFromWorker, sendHandle);
+		} catch (e) {
+			errorHandler(msgToWorker.stencilId, e);
+		}
+	});
+	process.on(`unhandledRejection`, (e) => {
+		errorHandler(-1, e);
+	});
+};
+const msgHandler = createWorkerMessageHandler(createNodeSys({ process }));
+initNodeWorkerThread(process, msgHandler);
+//#endregion
+export {};

package/dist/testing/index.d.mts

@@ -0,0 +1,209 @@
+import { B as ComponentCompilerMeta, Ct as HostElement, E as CompilerCtx, Rr as Diagnostic, Rt as Module, Sa as UserBuildConditionals, Ut as NewSpecPageOptions, _a as ErrorHandler, a as BuildCtx, ai as LoggerTimeSpan, ei as LoadConfigInit, fa as UnvalidatedConfig, ft as ComponentRuntimeMeta, gr as CompilerSystem, ia as Testing, ni as LogLevel, pa as ValidatedConfig, pn as RuntimeRef, ri as Logger, vn as SpecPage, wt as HostRef, ya as RafCallback } from "../index-D-LlB2nw.mjs";
+import { c as getMode, d as Fragment, f as createEvent, g as Env, h as setAssetPath, i as getRenderingRef, m as getAssetPath, n as h, p as getElement, r as forceUpdate, t as Host, u as Mixin } from "../index-fIuYTL9f.mjs";
+import { Mock } from "vitest";
+
+//#region src/testing/testing-logger.d.ts
+declare class TestingLogger implements Logger {
+  private isEnabled;
+  enable(): void;
+  setLevel(_level: LogLevel): void;
+  getLevel(): LogLevel;
+  enableColors(_useColors: boolean): void;
+  emoji(_: string): 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;
+  bgRed(msg: string): string;
+  createTimeSpan(_startMsg: string, _debug?: boolean): LoggerTimeSpan;
+  printDiagnostics(_diagnostics: Diagnostic[]): void;
+}
+//#endregion
+//#region src/testing/testing-sys.d.ts
+interface TestingSystem extends CompilerSystem {
+  diskReads: number;
+  diskWrites: number;
+}
+declare const createTestingSystem: () => TestingSystem;
+//#endregion
+//#region src/testing/mocks.d.ts
+/**
+ * Generates a stub {@link d.ComponentCompilerMeta}. This function uses sensible defaults for the initial stub. However,
+ * any field in the object may be overridden via the `overrides` argument.
+ * @param overrides a partial implementation of `ComponentCompilerMeta`. Any provided fields will override the
+ * defaults provided by this function.
+ * @returns the stubbed `ComponentCompilerMeta`
+ */
+declare const mockComponentMeta: (overrides?: Partial<ComponentCompilerMeta>) => ComponentCompilerMeta;
+/**
+ * Creates a mock instance of an internal, validated Stencil configuration object
+ * the caller
+ * @param overrides a partial implementation of `ValidatedConfig`. Any provided fields will override the defaults
+ * provided by this function.
+ * @returns the mock Stencil configuration
+ */
+declare function mockValidatedConfig(overrides?: Partial<ValidatedConfig>): ValidatedConfig;
+/**
+ * Creates a mock instance of a Stencil configuration entity. The mocked configuration has no guarantees around the
+ * types/validity of its data.
+ * @param overrides a partial implementation of `UnvalidatedConfig`. Any provided fields will override the defaults
+ * provided by this function.
+ * @returns the mock Stencil configuration
+ */
+declare function mockConfig(overrides?: Partial<UnvalidatedConfig>): UnvalidatedConfig;
+/**
+ * Creates a configuration object used to bootstrap a Stencil 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
+ */
+declare const mockLoadConfigInit: (overrides?: Partial<LoadConfigInit>) => LoadConfigInit;
+declare function mockCompilerCtx(config?: ValidatedConfig): CompilerCtx;
+declare function mockBuildCtx(config?: ValidatedConfig, compilerCtx?: CompilerCtx): BuildCtx;
+declare function mockLogger(): TestingLogger;
+/**
+ * Create a {@link d.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 Stencil engineers to reach for when attempting to mock a
+ * {@link d.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.
+ */
+declare function mockCompilerSystem(): TestingSystem;
+declare function mockDocument(html?: string | null): Document;
+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!
+ */
+declare const mockModule: (mod?: Partial<Module>) => Module;
+//#endregion
+//#region src/testing/spec-page.d.ts
+/**
+ * Creates a new spec page for unit testing
+ * @param opts the options to apply to the spec page that influence its configuration and operation
+ * @returns the created spec page
+ */
+declare function newSpecPage(opts: NewSpecPageOptions): Promise<SpecPage>;
+//#endregion
+//#region src/testing/testing-utils.d.ts
+/**
+ * Shuffle an array using Fisher-Yates algorithm
+ * http://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param array - the array to shuffle
+ * @returns the shuffled array
+ */
+declare function shuffleArray(array: any[]): any[];
+/**
+ * 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, teardownConsoleMocks } = setupConsoleMocker()
+ *
+ *   it("should log a message", () => {
+ *     const { logMock } = setupConsoleMocks();
+ *     myFunctionWhichLogs(foo, bar);
+ *     expect(logMock).toBeCalledWith('my log message');
+ *     teardownConsoleMocks();
+ *   })
+ * })
+ * ```
+ *
+ * @returns a per-test mock setup function
+ */
+declare function setupConsoleMocker(): ConsoleMocker;
+interface ConsoleMocker {
+  setupConsoleMocks: () => {
+    logMock: Mock<typeof console.log>;
+    warnMock: Mock<typeof console.warn>;
+    errorMock: Mock<typeof console.error>;
+  };
+  teardownConsoleMocks: () => void;
+}
+/**
+ * the callback that `withSilentWarn` expects to receive. Basically receives a mock
+ * as its argument and returns a `Promise`, the value of which is returned by `withSilentWarn`
+ * as well.
+ */
+//#endregion
+//#region src/testing/platform/testing-build.d.ts
+declare const Build: UserBuildConditionals;
+//#endregion
+//#region src/testing/platform/testing-host-ref.d.ts
+/**
+ * Retrieve the data structure tracking the component by its runtime reference
+ * @param elm the reference to the element
+ * @returns the corresponding Stencil reference data structure, or undefined if one cannot be found
+ */
+declare const getHostRef: (elm: RuntimeRef | undefined) => HostRef | undefined;
+/**
+ * Add the provided `hostRef` instance to the global {@link hostRefs} map, using the provided `lazyInstance` as a key.
+ * @param lazyInstance a Stencil component instance
+ * @param hostRef an optional reference to Stencil's tracking data for the component. If none is provided, one will be created.
+ * @throws if the provided `lazyInstance` coerces to `null`, or if the `lazyInstance` does not have a `constructor`
+ * property
+ */
+declare const registerInstance: (lazyInstance: any, hostRef: HostRef | null | undefined) => void;
+/**
+ * Create a new {@link d.HostRef} instance to the global {@link hostRefs} map, using the provided `elm` as a key.
+ * @param elm an HTMLElement instance associated with the Stencil component
+ * @param cmpMeta the component compiler metadata associated with the component
+ */
+declare const registerHost: (elm: HostElement, cmpMeta: ComponentRuntimeMeta) => void;
+//#endregion
+//#region src/testing/platform/testing-log.d.ts
+declare const setErrorHandler: (handler: ErrorHandler | undefined) => ErrorHandler;
+//#endregion
+//#region src/testing/platform/testing-task-queue.d.ts
+/**
+ * Push a RequestAnimationFrame callback onto the {@link queuedWriteTasks} data structure
+ * @param cb the callback to push onto `queuedWriteTasks`
+ */
+declare function writeTask(cb: RafCallback): void;
+/**
+ * Push a RequestAnimationFrame callback onto the {@link queuedReadTasks} data structure
+ * @param cb the callback to push onto `queuedReadTasks`
+ */
+declare function readTask(cb: RafCallback): void;
+//#endregion
+//#region src/testing/platform/index.d.ts
+declare const setMode: (handler: (elm: any) => string | undefined | null) => void;
+//#endregion
+export { Build, Env, Fragment, Host, Mixin, type SpecPage, type Testing, createEvent, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockBuildCtx, mockCompilerCtx, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };