@rindo/core 1.8.12

package/dist/client/shadow-css-8fd1a9e4.js

@@ -0,0 +1,388 @@
+'use strict';
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ *
+ * This file is a port of shadowCSS from webcomponents.js to TypeScript.
+ * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
+ * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts
+ */
+const safeSelector = (selector) => {
+    const placeholders = [];
+    let index = 0;
+    let content;
+    // Replaces attribute selectors with placeholders.
+    // The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
+    selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(keep);
+        index++;
+        return replaceBy;
+    });
+    // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
+    // WS and "+" would otherwise be interpreted as selector separators.
+    content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(exp);
+        index++;
+        return pseudo + replaceBy;
+    });
+    const ss = {
+        content,
+        placeholders,
+    };
+    return ss;
+};
+const restoreSafeSelector = (placeholders, content) => {
+    return content.replace(/__ph-(\d+)__/g, (_, index) => placeholders[+index]);
+};
+const _polyfillHost = '-shadowcsshost';
+const _polyfillSlotted = '-shadowcssslotted';
+// note: :host-context pre-processed to -shadowcsshostcontext.
+const _polyfillHostContext = '-shadowcsscontext';
+const _parenSuffix = ')(?:\\((' +
+    '(?:\\([^)(]*\\)|[^)(]*)+?' +
+    ')\\))?([^,{]*)';
+const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
+const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
+const _cssColonSlottedRe = new RegExp('(' + _polyfillSlotted + _parenSuffix, 'gim');
+const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
+const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
+const _shadowDOMSelectorsRe = [
+    /::shadow/g,
+    /::content/g
+];
+const _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
+const _polyfillHostRe = /-shadowcsshost/gim;
+const _colonHostRe = /:host/gim;
+const _colonSlottedRe = /::slotted/gim;
+const _colonHostContextRe = /:host-context/gim;
+const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+const stripComments = (input) => {
+    return input.replace(_commentRe, '');
+};
+const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g;
+const extractCommentsWithHash = (input) => {
+    return input.match(_commentWithHashRe) || [];
+};
+const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _curlyRe = /([{}])/g;
+const OPEN_CURLY = '{';
+const CLOSE_CURLY = '}';
+const BLOCK_PLACEHOLDER = '%BLOCK%';
+const processRules = (input, ruleCallback) => {
+    const inputWithEscapedBlocks = escapeBlocks(input);
+    let nextBlockIndex = 0;
+    return inputWithEscapedBlocks.escapedString.replace(_ruleRe, (...m) => {
+        const selector = m[2];
+        let content = '';
+        let suffix = m[4];
+        let contentPrefix = '';
+        if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
+            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
+            suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
+            contentPrefix = '{';
+        }
+        const cssRule = {
+            selector,
+            content
+        };
+        const rule = ruleCallback(cssRule);
+        return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
+    });
+};
+const escapeBlocks = (input) => {
+    const inputParts = input.split(_curlyRe);
+    const resultParts = [];
+    const escapedBlocks = [];
+    let bracketCount = 0;
+    let currentBlockParts = [];
+    for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
+        const part = inputParts[partIndex];
+        if (part === CLOSE_CURLY) {
+            bracketCount--;
+        }
+        if (bracketCount > 0) {
+            currentBlockParts.push(part);
+        }
+        else {
+            if (currentBlockParts.length > 0) {
+                escapedBlocks.push(currentBlockParts.join(''));
+                resultParts.push(BLOCK_PLACEHOLDER);
+                currentBlockParts = [];
+            }
+            resultParts.push(part);
+        }
+        if (part === OPEN_CURLY) {
+            bracketCount++;
+        }
+    }
+    if (currentBlockParts.length > 0) {
+        escapedBlocks.push(currentBlockParts.join(''));
+        resultParts.push(BLOCK_PLACEHOLDER);
+    }
+    const strEscapedBlocks = {
+        escapedString: resultParts.join(''),
+        blocks: escapedBlocks
+    };
+    return strEscapedBlocks;
+};
+const insertPolyfillHostInCssText = (selector) => {
+    selector = selector
+        .replace(_colonHostContextRe, _polyfillHostContext)
+        .replace(_colonHostRe, _polyfillHost)
+        .replace(_colonSlottedRe, _polyfillSlotted);
+    return selector;
+};
+const convertColonRule = (cssText, regExp, partReplacer) => {
+    // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
+    return cssText.replace(regExp, (...m) => {
+        if (m[2]) {
+            const parts = m[2].split(',');
+            const r = [];
+            for (let i = 0; i < parts.length; i++) {
+                const p = parts[i].trim();
+                if (!p)
+                    break;
+                r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
+            }
+            return r.join(',');
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+};
+const colonHostPartReplacer = (host, part, suffix) => {
+    return host + part.replace(_polyfillHost, '') + suffix;
+};
+const convertColonHost = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostRe, colonHostPartReplacer);
+};
+const colonHostContextPartReplacer = (host, part, suffix) => {
+    if (part.indexOf(_polyfillHost) > -1) {
+        return colonHostPartReplacer(host, part, suffix);
+    }
+    else {
+        return host + part + suffix + ', ' + part + ' ' + host + suffix;
+    }
+};
+const convertColonSlotted = (cssText, slotScopeId) => {
+    const slotClass = '.' + slotScopeId + ' > ';
+    const selectors = [];
+    cssText = cssText.replace(_cssColonSlottedRe, (...m) => {
+        if (m[2]) {
+            const compound = m[2].trim();
+            const suffix = m[3];
+            const slottedSelector = slotClass + compound + suffix;
+            let prefixSelector = '';
+            for (let i = m[4] - 1; i >= 0; i--) {
+                const char = m[5][i];
+                if (char === '}' || char === ',') {
+                    break;
+                }
+                prefixSelector = char + prefixSelector;
+            }
+            const orgSelector = prefixSelector + slottedSelector;
+            const addedSelector = `${prefixSelector.trimRight()}${slottedSelector.trim()}`;
+            if (orgSelector.trim() !== addedSelector.trim()) {
+                const updatedSelector = `${addedSelector}, ${orgSelector}`;
+                selectors.push({
+                    orgSelector,
+                    updatedSelector,
+                });
+            }
+            return slottedSelector;
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+    return {
+        selectors,
+        cssText
+    };
+};
+const convertColonHostContext = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostContextRe, colonHostContextPartReplacer);
+};
+const convertShadowDOMSelectors = (cssText) => {
+    return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
+};
+const makeScopeMatcher = (scopeSelector) => {
+    const lre = /\[/g;
+    const rre = /\]/g;
+    scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
+    return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
+};
+const selectorNeedsScoping = (selector, scopeSelector) => {
+    const re = makeScopeMatcher(scopeSelector);
+    return !re.test(selector);
+};
+const applySimpleSelectorScope = (selector, scopeSelector, hostSelector) => {
+    // In Android browser, the lastIndex is not reset when the regex is used in String.replace()
+    _polyfillHostRe.lastIndex = 0;
+    if (_polyfillHostRe.test(selector)) {
+        const replaceBy = `.${hostSelector}`;
+        return selector
+            .replace(_polyfillHostNoCombinatorRe, (_, selector) => {
+            return selector.replace(/([^:]*)(:*)(.*)/, (_, before, colon, after) => {
+                return before + replaceBy + colon + after;
+            });
+        })
+            .replace(_polyfillHostRe, replaceBy + ' ');
+    }
+    return scopeSelector + ' ' + selector;
+};
+const applyStrictSelectorScope = (selector, scopeSelector, hostSelector) => {
+    const isRe = /\[is=([^\]]*)\]/g;
+    scopeSelector = scopeSelector.replace(isRe, (_, ...parts) => parts[0]);
+    const className = '.' + scopeSelector;
+    const _scopeSelectorPart = (p) => {
+        let scopedP = p.trim();
+        if (!scopedP) {
+            return '';
+        }
+        if (p.indexOf(_polyfillHostNoCombinator) > -1) {
+            scopedP = applySimpleSelectorScope(p, scopeSelector, hostSelector);
+        }
+        else {
+            // remove :host since it should be unnecessary
+            const t = p.replace(_polyfillHostRe, '');
+            if (t.length > 0) {
+                const matches = t.match(/([^:]*)(:*)(.*)/);
+                if (matches) {
+                    scopedP = matches[1] + className + matches[2] + matches[3];
+                }
+            }
+        }
+        return scopedP;
+    };
+    const safeContent = safeSelector(selector);
+    selector = safeContent.content;
+    let scopedSelector = '';
+    let startIndex = 0;
+    let res;
+    const sep = /( |>|\+|~(?!=))\s*/g;
+    // If a selector appears before :host it should not be shimmed as it
+    // matches on ancestor elements and not on elements in the host's shadow
+    // `:host-context(div)` is transformed to
+    // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
+    // the `div` is not part of the component in the 2nd selectors and should not be scoped.
+    // Historically `component-tag:host` was matching the component so we also want to preserve
+    // this behavior to avoid breaking legacy apps (it should not match).
+    // The behavior should be:
+    // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
+    // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
+    //   `:host-context(tag)`)
+    const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
+    // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
+    let shouldScope = !hasHost;
+    while ((res = sep.exec(selector)) !== null) {
+        const separator = res[1];
+        const part = selector.slice(startIndex, res.index).trim();
+        shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+        const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
+        scopedSelector += `${scopedPart} ${separator} `;
+        startIndex = sep.lastIndex;
+    }
+    const part = selector.substring(startIndex);
+    shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+    scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
+    // replace the placeholders with their original values
+    return restoreSafeSelector(safeContent.placeholders, scopedSelector);
+};
+const scopeSelector = (selector, scopeSelectorText, hostSelector, slotSelector) => {
+    return selector.split(',')
+        .map(shallowPart => {
+        if (slotSelector && shallowPart.indexOf('.' + slotSelector) > -1) {
+            return shallowPart.trim();
+        }
+        if (selectorNeedsScoping(shallowPart, scopeSelectorText)) {
+            return applyStrictSelectorScope(shallowPart, scopeSelectorText, hostSelector).trim();
+        }
+        else {
+            return shallowPart.trim();
+        }
+    })
+        .join(', ');
+};
+const scopeSelectors = (cssText, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector) => {
+    return processRules(cssText, (rule) => {
+        let selector = rule.selector;
+        let content = rule.content;
+        if (rule.selector[0] !== '@') {
+            selector = scopeSelector(rule.selector, scopeSelectorText, hostSelector, slotSelector);
+        }
+        else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
+            rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
+            content = scopeSelectors(rule.content, scopeSelectorText, hostSelector, slotSelector);
+        }
+        const cssRule = {
+            selector: selector.replace(/\s{2,}/g, ' ').trim(),
+            content
+        };
+        return cssRule;
+    });
+};
+const scopeCssText = (cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector) => {
+    cssText = insertPolyfillHostInCssText(cssText);
+    cssText = convertColonHost(cssText);
+    cssText = convertColonHostContext(cssText);
+    const slotted = convertColonSlotted(cssText, slotScopeId);
+    cssText = slotted.cssText;
+    cssText = convertShadowDOMSelectors(cssText);
+    if (scopeId) {
+        cssText = scopeSelectors(cssText, scopeId, hostScopeId, slotScopeId);
+    }
+    cssText = cssText.replace(/-shadowcsshost-no-combinator/g, `.${hostScopeId}`);
+    cssText = cssText.replace(/>\s*\*\s+([^{, ]+)/gm, ' $1 ');
+    return {
+        cssText: cssText.trim(),
+        slottedSelectors: slotted.selectors,
+    };
+};
+const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
+    const hostScopeId = scopeId + '-h';
+    const slotScopeId = scopeId + '-s';
+    const commentsWithHash = extractCommentsWithHash(cssText);
+    cssText = stripComments(cssText);
+    const orgSelectors = [];
+    if (commentOriginalSelector) {
+        const processCommentedSelector = (rule) => {
+            const placeholder = `/*!@___${orgSelectors.length}___*/`;
+            const comment = `/*!@${rule.selector}*/`;
+            orgSelectors.push({ placeholder, comment });
+            rule.selector = placeholder + rule.selector;
+            return rule;
+        };
+        cssText = processRules(cssText, rule => {
+            if (rule.selector[0] !== '@') {
+                return processCommentedSelector(rule);
+            }
+            else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
+                rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
+                rule.content = processRules(rule.content, processCommentedSelector);
+                return rule;
+            }
+            return rule;
+        });
+    }
+    const scoped = scopeCssText(cssText, scopeId, hostScopeId, slotScopeId);
+    cssText = [scoped.cssText, ...commentsWithHash].join('\n');
+    if (commentOriginalSelector) {
+        orgSelectors.forEach(({ placeholder, comment }) => {
+            cssText = cssText.replace(placeholder, comment);
+        });
+    }
+    scoped.slottedSelectors.forEach(slottedSelector => {
+        cssText = cssText.replace(slottedSelector.orgSelector, slottedSelector.updatedSelector);
+    });
+    return cssText;
+};
+
+exports.scopeCss = scopeCss;

package/dist/compiler/app-core/app-es5-disabled.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare const generateEs5DisabledMessage: (config: d.Config, compilerCtx: d.CompilerCtx, outputTarget: d.OutputTargetWww) => Promise<string>;

package/dist/compiler/app-core/app-polyfills.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare function getClientPolyfill(config: d.Config, polyfillFile: string): Promise<string>;
+export declare function getAppBrowserCorePolyfills(config: d.Config): Promise<string>;

package/dist/compiler/app-core/build-conditionals.d.ts

@@ -0,0 +1,6 @@
+import * as d from '../../declarations';
+export declare function getBuildFeatures(cmps: d.ComponentCompilerMeta[]): d.BuildFeatures;
+export declare function updateComponentBuildConditionals(moduleMap: d.ModuleMap, cmps: d.ComponentCompilerMeta[]): void;
+export declare function updateBuildConditionals(config: d.Config, b: d.Build): void;
+export declare const BUILD: d.Build;
+export declare const NAMESPACE = "app";

package/dist/compiler/app-core/bundle-app-core.d.ts

@@ -0,0 +1,6 @@
+import * as d from '../../declarations';
+import { OutputOptions, RollupBuild } from 'rollup';
+export declare const bundleApp: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, build: d.Build, bundleAppOptions: d.BundleAppOptions) => Promise<RollupBuild>;
+export declare const generateRollupOutput: (build: RollupBuild, options: OutputOptions, config: d.Config, entryModules: d.EntryModule[]) => Promise<d.RollupResult[]>;
+export declare const DEFAULT_CORE = "\nexport * from '@rindo/core/platform';\nimport globals from '@rindo/core/global-scripts';\nexport { globals };\n";
+export declare const DEFAULT_ENTRY = "\nexport * from '@rindo/core';\n";

package/dist/compiler/app-core/component-styles.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+export declare const replaceStylePlaceholders: (cmps: d.ComponentCompilerMeta[], modeName: string, code: string) => string;
+export declare const getStyleTextPlaceholder: (cmp: d.ComponentCompilerMeta) => string;
+export declare const getAllModes: (cmps: d.ComponentCompilerMeta[]) => string[];

package/dist/compiler/app-core/format-component-runtime-meta.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+export declare const formatLazyBundleRuntimeMeta: (bundleId: any, cmps: d.ComponentCompilerMeta[]) => d.LazyBundleRuntimeData;
+export declare const formatComponentRuntimeMeta: (compilerMeta: d.ComponentCompilerMeta, includeMethods: boolean) => d.ComponentRuntimeMetaCompact;
+export declare const stringifyRuntimeData: (data: any) => string;

package/dist/compiler/app-core/optimize-module.d.ts

@@ -0,0 +1,7 @@
+import * as d from '../../declarations';
+export declare function optimizeModule(config: d.Config, compilerCtx: d.CompilerCtx, sourceTarget: d.SourceTarget, isCore: boolean, input: string): Promise<{
+    output: string;
+    sourceMap?: any;
+    diagnostics?: d.Diagnostic[];
+}>;
+export declare const getTerserOptions: (sourceTarget: d.SourceTarget, isDebug: boolean) => any;

package/dist/compiler/browser/build-conditionals-client.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare const BUILD: Required<d.Build>;
+export declare const NAMESPACE = "app";

package/dist/compiler/browser/compile-options.d.ts

@@ -0,0 +1,12 @@
+import * as d from '../../declarations';
+export declare const getCompileOptions: (input: d.CompileOptions, filePath: string) => d.CompileOptions;
+export declare const getTransformOptions: (compilerOpts: d.CompileOptions) => d.TransformOptions;
+export declare const getCompilerConfig: () => d.Config;
+export declare const getMinifyScriptOptions: (opts?: d.CompileScriptMinifyOptions) => {
+    options: any;
+    minifier: {
+        name: string;
+        version: string;
+        url: string;
+    };
+};

package/dist/compiler/browser/compile.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare const compile: (code: string, opts?: d.CompileOptions) => Promise<d.CompileResults>;

package/dist/compiler/browser/create-compiler.d.ts

@@ -0,0 +1,14 @@
+import * as d from '../../declarations';
+export declare const createCompiler: () => {
+    resolveId(importee: string, importer: string): d.ResolvedRindoData;
+    getLoadPath(filePath: string): string;
+    transform(code: string, filePath: string, opts?: d.CompileOptions): Promise<{
+        code: string;
+        map: any;
+        diagnostics: d.Diagnostic[];
+    }>;
+    writeBuild(): void;
+    reset: () => void;
+    getResolvedData: (id: string) => d.ResolvedRindoData;
+    setResolvedData: (id: string, r: d.ResolvedRindoData) => Map<string, d.ResolvedRindoData>;
+};

package/dist/compiler/browser/index.d.ts

@@ -0,0 +1,11 @@
+import path from 'path';
+export { compile } from './compile';
+export { getMinifyScriptOptions } from './compile-options';
+export { path };
+export { rindoRollupPlugin as rollupPlugin } from '../rollup-plugins/rindo-public-plugin';
+export declare const version = "0.0.0-rindo-dev";
+export declare const dependencies: {
+    name: string;
+    version: string;
+    url: string;
+}[];

package/dist/compiler/build/build-ctx.d.ts

@@ -0,0 +1,74 @@
+import * as d from '../../declarations';
+/**
+ * A new BuildCtx object is created for every build
+ * and rebuild.
+ */
+export declare class BuildContext implements d.BuildCtx {
+    buildId: number;
+    buildMessages: string[];
+    buildResults: d.BuildResults;
+    bundleBuildCount: number;
+    collections: d.Collection[];
+    completedTasks: d.BuildTask[];
+    compilerCtx: d.CompilerCtx;
+    components: d.ComponentCompilerMeta[];
+    componentGraph: Map<string, string[]>;
+    config: d.Config;
+    data: any;
+    diagnostics: d.Diagnostic[];
+    dirsAdded: string[];
+    dirsDeleted: string[];
+    entryModules: d.EntryModule[];
+    filesAdded: string[];
+    filesChanged: string[];
+    filesDeleted: string[];
+    filesUpdated: string[];
+    filesWritten: string[];
+    globalStyle: string;
+    hasConfigChanges: boolean;
+    hasFinished: boolean;
+    hasHtmlChanges: boolean;
+    hasPrintedResults: boolean;
+    hasServiceWorkerChanges: boolean;
+    hasScriptChanges: boolean;
+    hasStyleChanges: boolean;
+    hydrateAppFilePath: string;
+    indexBuildCount: number;
+    indexDoc: Document;
+    isRebuild: boolean;
+    moduleFiles: d.Module[];
+    packageJson: d.PackageJsonData;
+    packageJsonFilePath: string;
+    pendingCopyTasks: Promise<d.CopyResults>[];
+    requiresFullBuild: boolean;
+    scriptsAdded: string[];
+    scriptsDeleted: string[];
+    startTime: number;
+    styleBuildCount: number;
+    stylesPromise: Promise<void>;
+    stylesUpdated: d.BuildStyleUpdate[];
+    timeSpan: d.LoggerTimeSpan;
+    timestamp: string;
+    transpileBuildCount: number;
+    validateTypesPromise: Promise<d.ValidateTypesResults>;
+    constructor(config: d.Config, compilerCtx: d.CompilerCtx);
+    start(): void;
+    createTimeSpan(msg: string, debug?: boolean): {
+        duration: () => number;
+        finish: (finishedMsg: string, color?: string, bold?: boolean, newLineSuffix?: boolean) => number;
+    };
+    debug(msg: string): void;
+    get hasError(): boolean;
+    get hasWarning(): boolean;
+    progress(t: d.BuildTask): void;
+    validateTypesBuild(): Promise<void>;
+}
+export declare const getBuildTimestamp: () => string;
+export declare const ProgressTask: {
+    emptyOutputTargets: {};
+    transpileApp: {};
+    generateStyles: {};
+    generateOutputTargets: {};
+    validateTypesBuild: {};
+    writeBuildFiles: {};
+};

package/dist/compiler/build/build-finish.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare const buildFinish: (buildCtx: d.BuildCtx) => Promise<d.BuildResults>;
+export declare const buildAbort: (buildCtx: d.BuildCtx) => Promise<d.BuildResults>;

package/dist/compiler/build/build-hmr.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare const generateHmr: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx) => d.HotModuleReplacement;

package/dist/compiler/build/build-results.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare const generateBuildResults: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx) => d.BuildResults;

package/dist/compiler/build/build-stats.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare const generateBuildStats: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, buildResults: d.BuildResults) => Promise<void>;
+export declare const generateStatsOutputTarget: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, buildResults: d.BuildResults, outputTarget: d.OutputTargetStats) => Promise<void>;

package/dist/compiler/build/build.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function build(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<d.BuildResults>;

package/dist/compiler/build/cache-stats.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+export declare const writeCacheStats: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx) => void;
+export declare const getObjectSize: (data: any, obj: any) => void;
+export declare const objectSizeEstimate: (obj: any) => number;

package/dist/compiler/build/compiler-build-id.d.ts

@@ -0,0 +1,6 @@
+export declare const COMPILER_BUILD: {
+    id: string;
+    minfyJs: string;
+    optimizeCss: string;
+    transpiler: string;
+};

package/dist/compiler/build/compiler-ctx.d.ts

@@ -0,0 +1,44 @@
+import * as d from '../../declarations';
+import { BuildEvents } from '../events';
+/**
+ * The CompilerCtx is a persistent object that's reused throughout
+ * all builds and rebuilds. The data within this object is used
+ * for in-memory caching, and can be reset, but the object itself
+ * is always the same.
+ */
+export declare class CompilerContext implements d.CompilerCtx {
+    activeBuildId: number;
+    activeFilesAdded: string[];
+    activeFilesDeleted: string[];
+    activeFilesUpdated: string[];
+    activeDirsAdded: string[];
+    activeDirsDeleted: string[];
+    cache: d.Cache;
+    cachedStyleMeta: Map<string, d.StyleCompiler>;
+    collections: d.CollectionCompilerMeta[];
+    compilerOptions: any;
+    events: BuildEvents;
+    fs: d.InMemoryFileSystem;
+    fsWatcher: d.FsWatcher;
+    hasFsWatcherEvents: boolean;
+    hasLoggedServerUrl: boolean;
+    hasSuccessfulBuild: boolean;
+    isActivelyBuilding: boolean;
+    lastBuildResults: d.BuildResults;
+    lastBuildStyles: Map<string, string>;
+    lastComponentStyleInput: Map<string, string>;
+    moduleMap: d.ModuleMap;
+    nodeMap: WeakMap<object, any>;
+    resolvedCollections: Set<string>;
+    rollupCacheHydrate: any;
+    rollupCacheLazy: any;
+    rollupCacheNative: any;
+    rootTsFiles: string[];
+    tsService: d.TsService;
+    cachedGlobalStyle: string;
+    styleModeNames: Set<string>;
+    constructor(config: d.Config);
+    reset(): void;
+}
+export declare const getModule: (config: d.Config, compilerCtx: d.CompilerCtx, sourceFilePath: string) => d.Module;
+export declare const resetModule: (moduleFile: d.Module) => void;

package/dist/compiler/build/init-index-html.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function initIndexHtmls(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<void>;

package/dist/compiler/build/validate-files.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function validateBuildFiles(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<[void[], void]>;

package/dist/compiler/build/write-build.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function writeBuildFiles(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<void>;