@stencil/core 4.43.5 → 5.0.0-alpha.10

package/compiler/sys/in-memory-fs.d.ts

@@ -1,227 +0,0 @@
-import type * as d from '../../internal/index';
-/**
- * An in-memory FS which proxies the underlying OS filesystem using a simple
- * in-memory cache. FS writes can accumulate on the in-memory system, using an
- * API similar to Node.js' `"fs"` module, and then be committed to disk as a
- * unit.
- *
- * Files written to the in-memory system can be edited, deleted, and so on.
- * This allows the compiler to proceed freely as if it is modifying the
- * filesystem, modifying the world in whatever way suits it, while deferring
- * actual FS writes until the end of the compilation process, making actual
- * changes to the filesystem on disk contingent on an error-free build or any
- * other condition.
- *
- * Usage example:
- *
- * ```ts
- * // create an in-memory FS
- * const sys = createSystem();
- * const inMemoryFs = createInMemoryFs(sys);
- *
- * // do a few fs operations
- * await inMemoryFs.writeFile("path/to/file.js", 'console.log("hey!");')
- * await inMemoryFs.remove("path/to/another_file.ts");
- *
- * // commit the results to disk
- * const commitStats = await inMemoryFs.commit();
- * ```
- *
- * In the above example the write operation and the delete operation (w/
- * `.remove`) are both queued in the in-memory proxy but not committed to
- * disk until the `.commit` method is called.
- */
-export type InMemoryFileSystem = ReturnType<typeof createInMemoryFs>;
-/**
- * A node in the in-memory file system. This may represent a file or
- * a directory, and pending copy, write, and delete operations may be stored
- * on it.
- */
-export interface FsItem {
-    fileText: string;
-    isFile: boolean;
-    isDirectory: boolean;
-    size: number;
-    mtimeMs: number;
-    exists: boolean;
-    queueCopyFileToDest: string;
-    queueWriteToDisk: boolean;
-    queueDeleteFromDisk?: boolean;
-    useCache: boolean;
-}
-/**
- * Storage format for the in-memory cache used to proxy the OS filesystem.
- *
- * Filesystem paths (of type `string`) are mapped to objects satisfying the
- * `FsItem` interface.
- */
-export type FsItems = Map<string, FsItem>;
-/**
- * Options supported by write methods on the in-memory filesystem.
- */
-export interface FsWriteOptions {
-    /**
-     * only use the in-memory cache and do not write the file to disk
-     */
-    inMemoryOnly?: boolean;
-    clearFileCache?: boolean;
-    /**
-     * flush the write to disk immediately, skipping the in-memory cache
-     */
-    immediateWrite?: boolean;
-    /**
-     * specify that the cache should be used
-     */
-    useCache?: boolean;
-    /**
-     * An optional tag for the current output target for which this file is being
-     * written.
-     */
-    outputTargetType?: string;
-}
-/**
- * Results from a write operation on the in-memory filesystem.
- */
-export interface FsWriteResults {
-    changedContent: boolean;
-    queuedWrite: boolean;
-    ignored: boolean;
-}
-/**
- * Options supported by read methods on the in-memory filesystem.
- */
-export interface FsReadOptions {
-    useCache?: boolean;
-    setHash?: boolean;
-}
-/**
- * Options supported by the readdir option on the in-memory filesystem.
- */
-interface FsReaddirOptions {
-    inMemoryOnly?: boolean;
-    recursive?: boolean;
-    /**
-     * Directory names to exclude. Just the basename,
-     * not the entire path. Basically for "node_modules".
-     */
-    excludeDirNames?: string[];
-    /**
-     * Extensions we know we can avoid. Each extension
-     * should include the `.` so that we can test for both
-     * `.d.ts.` and `.ts`. If `excludeExtensions` isn't provided it
-     * doesn't try to exclude anything. This only checks against
-     * the filename, not directory names when recursive.
-     */
-    excludeExtensions?: string[];
-}
-/**
- * A result from a directory read operation
- */
-interface FsReaddirItem {
-    absPath: string;
-    relPath: string;
-    isDirectory: boolean;
-    isFile: boolean;
-}
-/**
- * Information about a file in the in-memory filesystem.
- */
-interface FsStat {
-    exists: boolean;
-    isFile: boolean;
-    isDirectory: boolean;
-    size: number;
-}
-/**
- * Create an in-memory FS which proxies the underlying OS filesystem using an
- * in-memory cache. FS writes can accumulate on the in-memory system, using an
- * API similar to Node.js' `"fs"` module, and then be committed to disk as a
- * unit.
- *
- * Files written to the in-memory system can be edited, deleted, and so on.
- * This allows the compiler to proceed freely as if it is modifying the
- * filesystem, modifying the world in whatever way suits it, while deferring
- * actual FS writes until the end of the compilation process, making actual
- * changes to the filesystem on disk contingent on an error-free build or any
- * other condition.
- *
- * @param sys a compiler system object
- * @returns an in-memory filesystem interface
- */
-export declare const createInMemoryFs: (sys: d.CompilerSystem) => {
-    access: (filePath: string) => Promise<boolean>;
-    accessSync: (filePath: string) => boolean;
-    cancelDeleteDirectoriesFromDisk: (dirPaths: string[]) => void;
-    cancelDeleteFilesFromDisk: (filePaths: string[]) => void;
-    clearCache: () => void;
-    clearDirCache: (dirPath: string) => void;
-    clearFileCache: (filePath: string) => void;
-    commit: () => Promise<FsCommitResults>;
-    copyFile: (src: string, dest: string) => Promise<void>;
-    emptyDirs: (dirs: string[]) => Promise<void>;
-    getBuildOutputs: () => d.BuildOutput[];
-    getItem: (itemPath: string) => FsItem;
-    getMemoryStats: () => string;
-    readFile: (filePath: string, opts?: FsReadOptions) => Promise<string>;
-    readFileSync: (filePath: string, opts?: FsReadOptions) => string;
-    readdir: (dirPath: string, opts?: FsReaddirOptions) => Promise<FsReaddirItem[]>;
-    remove: (itemPath: string) => Promise<void>;
-    stat: (itemPath: string) => Promise<FsStat>;
-    statSync: (itemPath: string) => FsStat;
-    sys: d.CompilerSystem;
-    writeFile: (filePath: string, content: string, opts?: FsWriteOptions) => Promise<FsWriteResults>;
-    writeFiles: (files: {
-        [filePath: string]: string;
-    } | Map<string, string>, opts?: FsWriteOptions) => Promise<FsWriteResults[]>;
-};
-/**
- * The information needed to carry out a file copy operation.
- *
- * `[ source, destination ]`
- */
-type FileCopyTuple = [string, string];
-/**
- * Collected instructions for all pending filesystem operations saved
- * to the in-memory filesystem.
- */
-interface FsCommitInstructions {
-    filesToDelete: string[];
-    filesToWrite: string[];
-    /**
-     * Files queued for copy operations are stored as an array of `[source, dest]`
-     * tuples.
-     */
-    filesToCopy: FileCopyTuple[];
-    dirsToDelete: string[];
-    dirsToEnsure: string[];
-}
-/**
- * Results from committing pending filesystem operations
- */
-interface FsCommitResults {
-    filesCopied: FileCopyTuple[];
-    filesWritten: string[];
-    filesDeleted: string[];
-    dirsDeleted: string[];
-    dirsAdded: string[];
-}
-/**
- * Given the current state of the in-memory proxy filesystem, collect all of
- * the changes that need to be made in order to commit the currently-pending
- * operations (e.g. write, copy, delete) to the OS filesystem.
- *
- * @param items the storage data structure for the in-memory FS cache
- * @returns a collection of all the operations that need to be done
- */
-export declare const getCommitInstructions: (items: FsItems) => FsCommitInstructions;
-/**
- * Check whether a given filepath should be ignored
- *
- * We have a little ignore list, and we just check whether the
- * filepath ends with any of the strings on the ignore list.
- *
- * @param filePath the filepath to check!
- * @returns whether we should ignore it or not
- */
-export declare const shouldIgnore: (filePath: string) => boolean;
-export {};

package/compiler/transpile.d.ts

@@ -1,32 +0,0 @@
-import type { TranspileOptions, TranspileResults } from '../internal/index';
-/**
- * The `transpile()` function inputs source code as a string, with various options
- * within the second argument. The function is stateless and returns a `Promise` of the
- * results, including diagnostics and the transpiled code. The `transpile()` function
- * does not handle any bundling, minifying, or precompiling any CSS preprocessing like
- * Sass or Less. The `transpileSync()` equivalent is available so the same function
- * it can be called synchronously. However, TypeScript must be already loaded within
- * the global for it to work, where as the async `transpile()` function will load
- * TypeScript automatically.
- *
- * Since TypeScript is used, the source code will transpile from TypeScript to JavaScript,
- * and does not require Babel presets. Additionally, the results includes an `imports`
- * array of all the import paths found in the source file. The transpile options can be
- * used to set the `module` format, such as `cjs`, and JavaScript `target` version, such
- * as `es2017`.
- *
- * @param code the code to transpile
- * @param opts options for the transpilation process
- * @returns a Promise wrapping the results of the transpilation
- */
-export declare const transpile: (code: string, opts?: TranspileOptions) => Promise<TranspileResults>;
-/**
- * Synchronous equivalent of the `transpile()` function. When used in a browser
- * environment, TypeScript must already be available globally, where as the async
- * `transpile()` function will load TypeScript automatically.
- *
- * @param code the code to transpile
- * @param opts options for the transpilation process
- * @returns the results of the transpilation
- */
-export declare const transpileSync: (code: string, opts?: TranspileOptions) => TranspileResults;

package/dev-server/client/app-error.d.ts

@@ -1,20 +0,0 @@
-import type { Diagnostic } from '../../declarations';
-interface AppErrorData {
-    window: Window;
-    buildResults: any;
-    openInEditor?: OpenInEditorCallback;
-}
-type OpenInEditorCallback = (data: {
-    file: string;
-    line: number;
-    column: number;
-}) => void;
-interface AppErrorResults {
-    diagnostics: Diagnostic[];
-    status: null | string;
-}
-export declare const appError: (data: AppErrorData) => AppErrorResults;
-export declare const clearAppErrorModal: (data: {
-    window: Window;
-}) => void;
-export {};

package/dev-server/client/events.d.ts

@@ -1,6 +0,0 @@
-export declare const emitBuildLog: (win: Window, buildLog: any) => void;
-export declare const emitBuildResults: (win: Window, buildResults: any) => void;
-export declare const emitBuildStatus: (win: Window, buildStatus: string) => void;
-export declare const onBuildLog: (win: Window, cb: (buildLog: any) => void) => void;
-export declare const onBuildResults: (win: Window, cb: (buildResults: any) => void) => void;
-export declare const onBuildStatus: (win: Window, cb: (buildStatus: string) => void) => void;

package/dev-server/client/hmr-components.d.ts

@@ -1,12 +0,0 @@
-/**
- * Perform Hot Module Replacement for a given Stencil component (identified
- * uniquely via its tag name) in the DOM tree rooted at a given starting
- * element.
- *
- * @param element the root element within which to do Hot Module Replacement
- * @param versionId the current HMR version ID
- * @param hmrTagNames an out param containing a list of updated Stencil
- * component tag names
- * @returns a reference to the tag name array
- */
-export declare const hmrComponents: (element: Element, versionId: string, hmrTagNames: string[]) => string[];

package/dev-server/client/hmr-external-styles.d.ts

@@ -1 +0,0 @@
-export declare const hmrExternalStyles: (elm: Element, versionId: string, cssFileNames: string[]) => string[];

package/dev-server/client/hmr-images.d.ts

@@ -1 +0,0 @@
-export declare const hmrImages: (win: Window, doc: Document, versionId: string, imageFileNames: string[]) => string[];

package/dev-server/client/hmr-inline-styles.d.ts

@@ -1 +0,0 @@
-export declare const hmrInlineStyles: (elm: Element, versionId: string, stylesUpdatedData: any[]) => any[];

package/dev-server/client/hmr-util.d.ts

@@ -1,39 +0,0 @@
-export declare const getHmrHref: (versionId: string, fileName: string, testUrl: string) => string;
-export declare const setQueryString: (url: string, qsKey: string, qsValue: string) => string;
-export declare const setHmrQueryString: (url: string, versionId: string) => string;
-export declare const updateCssUrlValue: (versionId: string, fileName: string, oldCss: string) => string;
-/**
- * Determine whether a given element is a `<link>` tag pointing to a stylesheet
- *
- * @param elm the element to check
- * @returns whether or not the element is a link stylesheet
- */
-export declare const isLinkStylesheet: (elm: Element) => boolean;
-/**
- * Determine whether or not a given element is a template element
- *
- * @param elm the element to check
- * @returns whether or not the element of interest is a template element
- */
-export declare const isTemplate: (elm: Element) => boolean;
-/**
- * Set a new hmr version ID into the `data-hmr` attribute on an element.
- *
- * @param elm the element on which to set the property
- * @param versionId a new HMR version id
- */
-export declare const setHmrAttr: (elm: Element, versionId: string) => void;
-/**
- * Determine whether or not an element has a shadow root
- *
- * @param elm the element to check
- * @returns whether or not it has a shadow root
- */
-export declare const hasShadowRoot: (elm: Element) => boolean;
-/**
- * Determine whether or not an element is an element node
- *
- * @param elm the element to check
- * @returns whether or not it is an element node
- */
-export declare const isElement: (elm: Element) => boolean;

package/dev-server/client/hmr-window.d.ts

@@ -1,10 +0,0 @@
-export declare const hmrWindow: (data: {
-    window: Window;
-    hmr: any;
-}) => {
-    updatedComponents: string[];
-    updatedExternalStyles: string[];
-    updatedInlineStyles: string[];
-    updatedImages: string[];
-    versionId: string;
-};

package/dev-server/client/index.d.ts

@@ -1,6 +0,0 @@
-export { appError, clearAppErrorModal } from './app-error';
-export { emitBuildLog, emitBuildResults, emitBuildStatus, onBuildLog, onBuildResults, onBuildStatus } from './events';
-export { hmrWindow } from './hmr-window';
-export { logBuild, logDiagnostic, logDisabled, logReload, logWarn } from './logger';
-export { initBuildProgress } from './progress';
-export { initBuildStatus } from './status';