@rindo/core 3.0.0 → 3.1.0

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

@@ -1,218 +1,218 @@
-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 {
-    inMemoryOnly?: boolean;
-    clearFileCache?: boolean;
-    immediateWrite?: boolean;
-    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 {};
+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 {
+    inMemoryOnly?: boolean;
+    clearFileCache?: boolean;
+    immediateWrite?: boolean;
+    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 +1,32 @@
-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;
+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,18 +1,18 @@
-interface AppErrorData {
-    window: Window;
-    buildResults: any;
-    openInEditor?: OpenInEditorCallback;
-}
-type OpenInEditorCallback = (data: {
-    file: string;
-    line: number;
-    column: number;
-}) => void;
-export declare const appError: (data: AppErrorData) => {
-    diagnostics: any[];
-    status: string;
-};
-export declare const clearAppErrorModal: (data: {
-    window: Window;
-}) => void;
-export {};
+interface AppErrorData {
+    window: Window;
+    buildResults: any;
+    openInEditor?: OpenInEditorCallback;
+}
+type OpenInEditorCallback = (data: {
+    file: string;
+    line: number;
+    column: number;
+}) => void;
+export declare const appError: (data: AppErrorData) => {
+    diagnostics: any[];
+    status: string;
+};
+export declare const clearAppErrorModal: (data: {
+    window: Window;
+}) => void;
+export {};

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

@@ -1,6 +1,6 @@
-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;
+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 +1 @@
-export declare const hmrComponents: (elm: Element, versionId: string, hmrTagNames: string[]) => string[];
+export declare const hmrComponents: (elm: Element, versionId: string, hmrTagNames: string[]) => string[];

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

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

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

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

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

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

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

@@ -1,9 +1,9 @@
-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;
-export declare const isLinkStylesheet: (elm: Element) => boolean;
-export declare const isTemplate: (elm: Element) => boolean;
-export declare const setHmrAttr: (elm: Element, versionId: string) => void;
-export declare const hasShadowRoot: (elm: Element) => boolean;
-export declare const isElement: (elm: Element) => boolean;
+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;
+export declare const isLinkStylesheet: (elm: Element) => boolean;
+export declare const isTemplate: (elm: Element) => boolean;
+export declare const setHmrAttr: (elm: Element, versionId: string) => void;
+export declare const hasShadowRoot: (elm: Element) => boolean;
+export declare const isElement: (elm: Element) => boolean;

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

@@ -1,10 +1,10 @@
-export declare const hmrWindow: (data: {
-    window: Window;
-    hmr: any;
-}) => {
-    updatedComponents: string[];
-    updatedExternalStyles: string[];
-    updatedInlineStyles: string[];
-    updatedImages: string[];
-    versionId: string;
-};
+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 +1,6 @@
-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';
+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';