@stencil/core 4.43.1 → 5.0.0-next.0

package/internal/testing/jsx-dev-runtime.d.ts

@@ -1,2 +0,0 @@
-// Type definitions for automatic JSX development runtime in testing
-export { jsxDEV, Fragment, JSX } from '../stencil-core/jsx-dev-runtime';

package/internal/testing/jsx-dev-runtime.js

@@ -1,8 +0,0 @@
-// Export automatic JSX development runtime for testing
-// This file allows TypeScript's automatic JSX transform to work in tests
-// when using jsxImportSource: "@stencil/core/internal/testing" with jsx: "react-jsxdev"
-const testing = require('./index.js');
-module.exports = {
-  jsxDEV: testing.jsxDEV,
-  Fragment: testing.Fragment,
-};

package/internal/testing/jsx-runtime.d.ts

@@ -1,2 +0,0 @@
-// Type definitions for automatic JSX runtime in testing
-export { jsx, jsxs, Fragment, JSX } from '../stencil-core/jsx-runtime';

package/internal/testing/jsx-runtime.js

@@ -1,9 +0,0 @@
-// Export automatic JSX runtime for testing
-// This file allows TypeScript's automatic JSX transform to work in tests
-// when using jsxImportSource: "@stencil/core/internal/testing"
-const testing = require('./index.js');
-module.exports = {
-  jsx: testing.jsx,
-  jsxs: testing.jsxs,
-  Fragment: testing.Fragment,
-};

package/internal/testing/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "@stencil/core/internal/testing",
-  "version": "4.43.1",
-  "description": "Stencil internal testing platform to be imported by the Stencil Compiler. Breaking changes can and will happen at any time.",
-  "main": "./index.js",
-  "private": true
-}

package/internal/utils/index.d.ts

@@ -1 +0,0 @@
-export * as result from "./result"

package/internal/utils/result.d.ts

@@ -1,112 +0,0 @@
-/**
- * A Result wraps up a success state and a failure state, allowing you to
- * return a single type from a function and discriminate between the two
- * possible states in a principled way.
- *
- * Using it could look something like this:
- *
- * ```ts
- * import { result } from '@utils';
- *
- * const mightFail = (input: number): Result<number, string> => {
- *   try {
- *     let value: number = calculateSomethingWithInput(input);
- *     return result.ok(value);
- *   } catch (e) {
- *     return result.err(e.message);
- *   }
- * }
- *
- * const sumResult = mightFail(2);
- *
- * const msg = result.map(sumResult, (sum: number) => `the sum was: ${sum}`);
- * ```
- *
- * A few utility methods are defined in this module, like `map` and `unwrap`,
- * which are (probably obviously) inspired by the correspond methods on
- * `std::result::Result` in Rust.
- */
-export type Result<OnSuccess, OnFailure> = Ok<OnSuccess> | Err<OnFailure>;
-/**
- * Type for the Ok state of a Result
- */
-type Ok<T> = {
-    isOk: true;
-    isErr: false;
-    value: T;
-};
-/**
- * Type for the Err state of a Result
- */
-type Err<T> = {
-    isOk: false;
-    isErr: true;
-    value: T;
-};
-/**
- * Create an `Ok` given a value. This doesn't do any checking that the value is
- * 'ok-ish' since doing so would make an undue assumption about what is 'ok'.
- * Instead, this trusts the user to determine, at the call site, whether
- * something is `ok()` or `err()`.
- *
- * @param value the value to wrap up in an `Ok`
- * @returns an Ok wrapping the value
- */
-export declare const ok: <T>(value: T) => Ok<T>;
-/**
- * Create an `Err` given a value.
- *
- * @param value the value to wrap up in an `Err`
- * @returns an Ok wrapping the value
- */
-export declare const err: <T>(value: T) => Err<T>;
-/**
- * Map across a `Result`.
- *
- * If it's `Ok`, unwraps the value, applies the supplied function, and returns
- * the result, wrapped in `Ok` again. This could involve changing the type of
- * the wrapped value, for instance:
- *
- * ```ts
- * import { result } from "@utils";
- *
- * const myResult: Result<string, string> = result.ok("monads???");
- * const updatedResult = result.map(myResult, wrappedString => (
- *   wrappedString.split("").length
- * ));
- * ```
- *
- * after the `result.map` call the type of `updatedResult` will now be
- * `Result<number, string>`.
- *
- * If it's `Err`, just return the same value.
- *
- * This lets the programmer trigger an action, or transform a value, only if an
- * earlier operation succeeded, short-circuiting instead if an error occurred.
- *
- * @param result a `Result` value which we want to map across
- * @param fn a function for handling the `Ok` case for the `Result`
- * @returns a new `Result`, with the a new wrapped value (if `Ok`) or the
- * same (if `Err)
- */
-export declare function map<T1, T2, E>(result: Result<T1, E>, fn: (t: T1) => Promise<T2>): Promise<Result<T2, E>>;
-export declare function map<T1, T2, E>(result: Result<T1, E>, fn: (t: T1) => T2): Result<T2, E>;
-/**
- * Unwrap a {@link Result}, return the value inside if it is an `Ok` and
- * throw with the wrapped value if it is an `Err`.
- *
- * @throws with the wrapped value if it is an `Err`.
- * @param result a result to peer inside of
- * @returns the wrapped value, if `Ok`
- */
-export declare const unwrap: <T, E>(result: Result<T, E>) => T;
-/**
- * Unwrap a {@link Result}, return the value inside if it is an `Err` and
- * throw with the wrapped value if it is an `Ok`.
- *
- * @throws with the wrapped value if it is an `Ok`.
- * @param result a result to peer inside of
- * @returns the wrapped value, if `Err`
- */
-export declare const unwrapErr: <T, E>(result: Result<T, E>) => E;
-export {};