@rindo/core 1.8.12

package/dist/declarations/logger.d.ts

@@ -0,0 +1,25 @@
+import { Diagnostic } from './diagnostics';
+export interface Logger {
+    level: string;
+    debug(...msg: any[]): void;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    createTimeSpan(startMsg: string, debug?: boolean, appendTo?: string[]): LoggerTimeSpan;
+    printDiagnostics(diagnostics: Diagnostic[], cwd?: string): 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;
+    buildLogFilePath: string;
+    writeLogs(append: boolean): void;
+}
+export interface LoggerTimeSpan {
+    duration(): number;
+    finish(finishedMsg: string, color?: string, bold?: boolean, newLineSuffix?: boolean): number;
+}

package/dist/declarations/minify-js.d.ts

@@ -0,0 +1,11 @@
+export interface MinifyJsResult {
+    code: string;
+    sourceMap: any;
+    error: {
+        message: string;
+        filename: string;
+        line: number;
+        col: number;
+        pos: number;
+    };
+}

package/dist/declarations/module.d.ts

@@ -0,0 +1,35 @@
+import { ComponentCompilerMeta } from './component-compiler-meta';
+export declare type ModuleMap = Map<string, Module>;
+/**
+ * Module gets serialized/parsed as JSON
+ * cannot use Map or Set
+ */
+export interface Module {
+    cmps: ComponentCompilerMeta[];
+    coreRuntimeApis: string[];
+    collectionName: string;
+    dtsFilePath: string;
+    excludeFromCollection: boolean;
+    externalImports: string[];
+    htmlAttrNames: string[];
+    htmlTagNames: string[];
+    isCollectionDependency: boolean;
+    isLegacy: boolean;
+    jsFilePath: string;
+    localImports: string[];
+    originalImports: string[];
+    originalCollectionComponentPath: string;
+    potentialCmpRefs: string[];
+    sourceFilePath: string;
+    hasVdomAttribute: boolean;
+    hasVdomClass: boolean;
+    hasVdomFunctional: boolean;
+    hasVdomKey: boolean;
+    hasVdomListener: boolean;
+    hasVdomPropOrAttr: boolean;
+    hasVdomRef: boolean;
+    hasVdomRender: boolean;
+    hasVdomStyle: boolean;
+    hasVdomText: boolean;
+    hasVdomXlink: boolean;
+}

package/dist/declarations/optimize-css.d.ts

@@ -0,0 +1,12 @@
+import { Diagnostic } from './diagnostics';
+export interface OptimizeCssInput {
+    css: string;
+    filePath: string;
+    autoprefixer: any;
+    minify: boolean;
+    legecyBuild: boolean;
+}
+export interface OptimizeCssOutput {
+    css: string;
+    diagnostics?: Diagnostic[];
+}

package/dist/declarations/output-targets.d.ts

@@ -0,0 +1,189 @@
+import { Config, ServiceWorkerConfig } from './config';
+import { CopyTask } from './assets';
+import { Diagnostic } from './diagnostics';
+import { CompilerCtx } from './compiler';
+import { BuildCtx } from './build';
+import { JsonDocs } from './docs';
+export interface OutputTargetAngular extends OutputTargetBase {
+    type: 'angular';
+    componentCorePackage: string;
+    directivesProxyFile?: string;
+    directivesArrayFile?: string;
+    directivesUtilsFile?: string;
+    excludeComponents?: string[];
+}
+export interface OutputTargetCopy extends OutputTargetBase {
+    type: 'copy';
+    dir: string;
+    copy?: CopyTask[];
+    copyAssets?: 'collection' | 'dist';
+}
+export interface OutputTargetWww extends OutputTargetBase {
+    /**
+     * Webapp output target.
+     */
+    type: 'www';
+    /**
+     * The directory to write the app's JavaScript and CSS build
+     * files to. The default is to place this directory as a child
+     * to the `dir` config. Default: `build`
+     */
+    buildDir?: string;
+    /**
+     * The directory to write the entire application to.
+     * Note, the `buildDir` is where the app's JavaScript and CSS build
+     * files are written. Default: `www`
+     */
+    dir?: string;
+    /**
+     * Empty the build directory of all files and directories on first build.
+     * Default: `true`
+     */
+    empty?: boolean;
+    /**
+     * The default index html file of the app, commonly found at the
+     * root of the `src` directory.
+     * Default: `index.html`
+     */
+    indexHtml?: string;
+    /**
+     * The copy config is an array of objects that defines any files or folders that should
+     * be copied over to the build directory.
+     *
+     * Each object in the array must include a src property which can be either an absolute path,
+     * a relative path or a glob pattern. The config can also provide an optional dest property
+     * which can be either an absolute path or a path relative to the build directory.
+     * Also note that any files within src/assets are automatically copied to www/assets for convenience.
+     *
+     * In the copy config below, it will copy the entire directory from src/docs-content over to www/docs-content.
+     */
+    copy?: CopyTask[];
+    /**
+     * The base url of the app, it's required during prerendering to be the absolute path
+     * of your app, such as: `https://my.app.com/app`.
+     *
+     * Default: `/`
+     */
+    baseUrl?: string;
+    /**
+     * By default, rindo will include all the polyfills required by legacy browsers in the ES5 build.
+     * If it's `false`, rindo will not emit this polyfills anymore and it's your responsability to provide them before
+     * rindo initializes.
+     */
+    polyfills?: boolean;
+    /**
+     * Path to an external node module which has exports of the prerender config object.
+     * ```
+     * module.exports = {
+     *   afterHydrate(document, url) {
+     *     document.title = `URL: ${url.href}`;
+     *   }
+     * }
+     * ```
+     */
+    prerenderConfig?: string;
+    serviceWorker?: ServiceWorkerConfig | null;
+    appDir?: string;
+}
+export interface OutputTargetDist extends OutputTargetBase {
+    type: 'dist';
+    buildDir?: string;
+    dir?: string;
+    collectionDir?: string | null;
+    typesDir?: string;
+    esmLoaderPath?: string;
+    copy?: CopyTask[];
+    empty?: boolean;
+}
+export interface OutputTargetDistCollection extends OutputTargetBase {
+    type: 'dist-collection';
+    dir: string;
+    collectionDir: string;
+}
+export interface OutputTargetDistTypes extends OutputTargetBase {
+    type: 'dist-types';
+    dir: string;
+    typesDir: string;
+}
+export interface OutputTargetDistLazy extends OutputTargetBase {
+    type: 'dist-lazy';
+    esmDir?: string;
+    esmEs5Dir?: string;
+    systemDir?: string;
+    cjsDir?: string;
+    polyfills?: boolean;
+    isBrowserBuild?: boolean;
+    esmIndexFile?: string;
+    cjsIndexFile?: string;
+    systemLoaderFile?: string;
+    legacyLoaderFile?: string;
+}
+export interface OutputTargetDistGlobalStyles extends OutputTargetBase {
+    type: 'dist-global-styles';
+    file: string;
+}
+export interface OutputTargetDistLazyLoader extends OutputTargetBase {
+    type: 'dist-lazy-loader';
+    dir: string;
+    esmDir: string;
+    esmEs5Dir: string;
+    cjsDir: string;
+    componentDts: string;
+    empty: boolean;
+}
+export interface OutputTargetDistModule extends OutputTargetBase {
+    type: 'experimental-dist-module';
+    dir?: string;
+    externalRuntime?: boolean;
+    empty?: boolean;
+    copy?: CopyTask[];
+}
+export interface OutputTargetDistSelfContained extends OutputTargetBase {
+    type: 'dist-self-contained';
+    dir?: string;
+    buildDir?: string;
+    empty?: boolean;
+}
+export interface OutputTargetHydrate extends OutputTargetBase {
+    type: 'dist-hydrate-script';
+    dir?: string;
+    empty?: boolean;
+}
+export interface OutputTargetCustom extends OutputTargetBase {
+    type: 'custom';
+    name: string;
+    validate?: (config: Config, diagnostics: Diagnostic[]) => void;
+    generator: (config: Config, compilerCtx: CompilerCtx, buildCtx: BuildCtx, docs: JsonDocs) => Promise<void>;
+    copy?: CopyTask[];
+}
+export interface OutputTargetDocsVscode extends OutputTargetBase {
+    type: 'docs-vscode';
+    file: string;
+    sourceCodeBaseUrl?: string;
+}
+export interface OutputTargetDocsReadme extends OutputTargetBase {
+    type: 'docs-readme' | 'docs';
+    dir?: string;
+    footer?: string;
+    strict?: boolean;
+}
+export interface OutputTargetDocsJson extends OutputTargetBase {
+    type: 'docs-json';
+    file: string;
+    typesFile?: string | null;
+    strict?: boolean;
+}
+export interface OutputTargetDocsCustom extends OutputTargetBase {
+    type: 'docs-custom';
+    generator: (docs: JsonDocs) => void | Promise<void>;
+    strict?: boolean;
+}
+export interface OutputTargetStats extends OutputTargetBase {
+    type: 'stats';
+    file?: string;
+}
+export interface OutputTargetBase {
+    type: string;
+}
+export declare type OutputTargetBuild = OutputTargetDistCollection | OutputTargetDistLazy;
+export declare type OutputTarget = OutputTargetAngular | OutputTargetCopy | OutputTargetCustom | OutputTargetDist | OutputTargetDistCollection | OutputTargetDistLazy | OutputTargetDistGlobalStyles | OutputTargetDistLazyLoader | OutputTargetDistModule | OutputTargetDistSelfContained | OutputTargetDocsJson | OutputTargetDocsCustom | OutputTargetDocsReadme | OutputTargetDocsVscode | OutputTargetWww | OutputTargetHydrate | OutputTargetStats | OutputTargetDistTypes;

package/dist/declarations/plugin.d.ts

@@ -0,0 +1,23 @@
+import { Cache } from './cache';
+import { Config } from './config';
+import { Diagnostic } from './diagnostics';
+import { InMemoryFileSystem } from './in-memory-fs';
+import { RindoSystem } from './system';
+export interface Plugin {
+    name?: string;
+    pluginType?: string;
+    load?: (id: string, context: PluginCtx) => Promise<string> | string;
+    resolveId?: (importee: string, importer: string, context: PluginCtx) => Promise<string> | string;
+    transform?: (sourceText: string, id: string, context: PluginCtx) => Promise<PluginTransformResults> | PluginTransformResults | string;
+}
+export interface PluginTransformResults {
+    code?: string;
+    id?: string;
+}
+export interface PluginCtx {
+    config: Config;
+    sys: RindoSystem;
+    fs: InMemoryFileSystem;
+    cache: Cache;
+    diagnostics: Diagnostic[];
+}

package/dist/declarations/prerender.d.ts

@@ -0,0 +1,79 @@
+import { Config } from './config';
+import { Diagnostic } from './diagnostics';
+import { OutputTargetWww } from './output-targets';
+import { SerializeDocumentOptions } from './hydrate';
+export interface ProgressLogger {
+    update(text: string): Promise<void>;
+    stop(): Promise<void>;
+}
+export interface PrerenderManager {
+    config: Config;
+    devServerHostUrl: string;
+    diagnostics: Diagnostic[];
+    hydrateAppFilePath: string;
+    isDebug: boolean;
+    logCount: number;
+    outputTarget: OutputTargetWww;
+    prerenderConfig: PrerenderConfig;
+    prerenderConfigPath: string;
+    progressLogger?: ProgressLogger;
+    resolve: Function;
+    templateId: string;
+    componentGraphPath: string;
+    urlsProcessing: Set<string>;
+    urlsPending: Set<string>;
+    urlsCompleted: Set<string>;
+    maxConcurrency: number;
+}
+export interface PrerenderRequest {
+    baseUrl: string;
+    componentGraphPath: string;
+    devServerHostUrl: string;
+    hydrateAppFilePath: string;
+    prerenderConfigPath: string;
+    templateId: string;
+    url: string;
+    writeToFilePath: string;
+}
+export interface PrerenderResults {
+    anchorUrls: string[];
+    diagnostics: Diagnostic[];
+    filePath: string;
+}
+export interface PrerenderConfig {
+    afterHydrate?(document?: Document, url?: URL): any | Promise<any>;
+    beforeHydrate?(document?: Document, url?: URL): any | Promise<any>;
+    canonicalUrl?(url?: URL): string | null;
+    entryUrls?: string[];
+    filterAnchor?(attrs: {
+        [attrName: string]: string;
+    }, base?: URL): boolean;
+    filterUrl?(url?: URL, base?: URL): boolean;
+    filePath?(url?: URL, filePath?: string): string;
+    hydrateOptions?(url?: URL): SerializeDocumentOptions;
+    normalizeUrl?(href?: string, base?: URL): URL;
+    robotsTxt?(opts: RobotsTxtOpts): string | RobotsTxtResults;
+    sitemapXml?(opts: SitemapXmpOpts): string | SitemapXmpResults;
+    trailingSlash?: boolean;
+}
+export interface RobotsTxtOpts {
+    urls: string[];
+    sitemapUrl: string;
+    baseUrl: string;
+    dir: string;
+}
+export interface RobotsTxtResults {
+    content: string;
+    filePath: string;
+    url: string;
+}
+export interface SitemapXmpOpts {
+    urls: string[];
+    baseUrl: string;
+    dir: string;
+}
+export interface SitemapXmpResults {
+    content: string;
+    filePath: string;
+    url: string;
+}

package/dist/declarations/render.d.ts

@@ -0,0 +1,62 @@
+import { HostElement } from './host-element';
+/**
+ * Generic node that represents all of the
+ * different types of nodes we'd see when rendering
+ */
+export interface RenderNode extends HostElement {
+    /**
+     * Shadow root's host
+     */
+    host?: Element;
+    /**
+     * Is Content Reference Node:
+     * This node is a content reference node.
+     */
+    ['s-cn']?: boolean;
+    /**
+     * Is a slot reference node:
+     * This is a node that represents where a slots
+     * was originally located.
+     */
+    ['s-sr']?: boolean;
+    /**
+     * Slot name
+     */
+    ['s-sn']?: string;
+    /**
+     * Host element tag name:
+     * The tag name of the host element that this
+     * node was created in.
+     */
+    ['s-hn']?: string;
+    /**
+     * Original Location Reference:
+     * A reference pointing to the comment
+     * which represents the original location
+     * before it was moved to its slot.
+     */
+    ['s-ol']?: RenderNode;
+    /**
+     * Node reference:
+     * This is a reference for a original location node
+     * back to the node that's been moved around.
+     */
+    ['s-nr']?: RenderNode;
+    /**
+     * Scope Id
+     */
+    ['s-si']?: string;
+    /**
+     * Host Id (hydrate only)
+     */
+    ['s-host-id']?: number;
+    /**
+     * Node Id (hydrate only)
+     */
+    ['s-node-id']?: number;
+    /**
+     * Used to know the components encapsulation.
+     * empty "" for shadow, "c" from scoped
+     */
+    ['s-en']?: '' | 'c';
+}

package/dist/declarations/runtime.d.ts

@@ -0,0 +1,92 @@
+import { ComponentConstructorWatchers } from './component-constructor';
+import { ComponentInterface } from './component-interfaces';
+import { HostElement } from './host-element';
+import { RenderNode } from './render';
+import { VNode } from './vdom';
+import { CssVarShim } from './css-var-shim';
+export declare type LazyBundlesRuntimeData = LazyBundleRuntimeData[];
+export declare type LazyBundleRuntimeData = [
+/** bundleIds */
+any, ComponentRuntimeMetaCompact[]];
+export declare type ComponentRuntimeMetaCompact = [
+/** flags */
+number, 
+/** tagname */
+string, 
+/** members */
+{
+    [memberName: string]: ComponentRuntimeMember;
+}?, 
+/** listeners */
+ComponentRuntimeHostListener[]?];
+export interface ComponentRuntimeMeta {
+    $flags$: number;
+    $tagName$: string;
+    $members$?: ComponentRuntimeMembers;
+    $listeners$?: ComponentRuntimeHostListener[];
+    $attrsToReflect$?: [string, string][];
+    $watchers$?: ComponentConstructorWatchers;
+    $lazyBundleIds$?: ModeBundleIds;
+}
+export interface ComponentRuntimeMembers {
+    [memberName: string]: ComponentRuntimeMember;
+}
+export declare type ComponentRuntimeMember = [
+/**
+ * flags data
+ */
+number, 
+/**
+ * attribute name to observe
+ */
+string?];
+export declare type ComponentRuntimeHostListener = [
+/**
+ * event flags
+ */
+number, 
+/**
+ * event name,
+ */
+string, 
+/**
+ * event method,
+ */
+string];
+export declare type ModeBundleId = ModeBundleIds | string;
+export interface ModeBundleIds {
+    [modeName: string]: string;
+}
+export declare type RuntimeRef = HostElement | {};
+export interface HostRef {
+    $ancestorComponent$?: HostElement;
+    $flags$: number;
+    $hostElement$?: HostElement;
+    $instanceValues$?: Map<string, any>;
+    $lazyInstance$?: ComponentInterface;
+    $onReadyPromise$?: Promise<any>;
+    $onReadyResolve$?: (elm: any) => void;
+    $onInstancePromise$?: Promise<any>;
+    $onInstanceResolve$?: (elm: any) => void;
+    $onRenderResolve$?: () => void;
+    $vnode$?: VNode;
+    $queuedListeners$?: [string, any][];
+    $rmListeners$?: () => void;
+    $modeName$?: string;
+    $renderCount$?: number;
+}
+export interface PlatformRuntime {
+    $flags$: number;
+    $resourcesUrl$: string;
+    jmp: (c: Function) => any;
+    raf: (c: FrameRequestCallback) => number;
+    ael: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+    rel: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+    $orgLocNodes$?: Map<string, RenderNode>;
+    $cssShim$?: CssVarShim;
+}
+export declare type RefMap = WeakMap<any, HostRef>;
+export declare type StyleMap = Map<string, CSSStyleSheet | string>;
+export declare type RootAppliedStyleMap = WeakMap<Element, Set<string>>;
+export declare type AppliedStyleMap = Set<string>;
+export declare type ActivelyProcessingCmpMap = Set<Element>;