@rindo/core 1.8.12

package/dist/compiler/transformers/legacy-props.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const addLegacyProps: (moduleFile: d.Module, cmp: d.ComponentCompilerMeta) => ts.ExpressionStatement[];

package/dist/compiler/transformers/remove-static-meta-properties.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const removeStaticMetaProperties: (classNode: ts.ClassDeclaration) => ts.ClassElement[];

package/dist/compiler/transformers/reserved-public-members.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const validatePublicName: (config: d.Config, diagnostics: d.Diagnostic[], memberName: string, decorator: string, memberType: string, node: ts.Node) => void;

package/dist/compiler/transformers/rindo-import-path.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare const createRindoImportPath: (type: d.RindoDataType, tagName: string, encapsulation: string, modeName: string, importPath: string) => string;
+export declare const parseRindoImportPath: (importee: string, importer: string) => d.ResolvedRindoData;

package/dist/compiler/transformers/static-to-meta/call-expression.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseCallExpression: (m: d.ComponentCompilerMeta | d.Module, node: ts.CallExpression) => void;

package/dist/compiler/transformers/static-to-meta/class-methods.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseClassMethods: (cmpNode: ts.ClassDeclaration, cmpMeta: d.ComponentCompilerMeta) => void;

package/dist/compiler/transformers/static-to-meta/component.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticComponentMeta: (config: d.Config, compilerCtx: d.CompilerCtx, typeChecker: ts.TypeChecker, cmpNode: ts.ClassDeclaration, moduleFile: d.Module, nodeMap: d.NodeMap, transformOpts: d.TransformOptions, fileCmpNodes: ts.ClassDeclaration[]) => ts.ClassDeclaration;

package/dist/compiler/transformers/static-to-meta/element-ref.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const parseStaticElementRef: (staticMembers: ts.ClassElement[]) => string;

package/dist/compiler/transformers/static-to-meta/encapsulation.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export declare const parseStaticEncapsulation: (staticMembers: ts.ClassElement[]) => "none" | "shadow" | "scoped";
+export declare const parseStaticShadowDelegatesFocus: (encapsulation: string, staticMembers: ts.ClassElement[]) => boolean;

package/dist/compiler/transformers/static-to-meta/events.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticEvents: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerEvent[];

package/dist/compiler/transformers/static-to-meta/import.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseImport: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, moduleFile: d.Module, dirPath: string, importNode: ts.ImportDeclaration) => ts.ImportDeclaration;

package/dist/compiler/transformers/static-to-meta/listeners.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticListeners: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerListener[];

package/dist/compiler/transformers/static-to-meta/methods.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticMethods: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerMethod[];

package/dist/compiler/transformers/static-to-meta/props.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticProps: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerProperty[];

package/dist/compiler/transformers/static-to-meta/states.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticStates: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerState[];

package/dist/compiler/transformers/static-to-meta/string-literal.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStringLiteral: (m: d.ComponentCompilerMeta | d.Module, node: ts.StringLiteral) => void;

package/dist/compiler/transformers/static-to-meta/styles.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticStyles: (config: d.Config, compilerCtx: d.CompilerCtx, tagName: string, componentFilePath: string, isCollectionDependency: boolean, staticMembers: ts.ClassElement[]) => d.StyleCompiler[];

package/dist/compiler/transformers/static-to-meta/vdom.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const gatherVdomMeta: (m: d.ComponentCompilerMeta | d.Module, args: ts.NodeArray<ts.Expression>) => void;

package/dist/compiler/transformers/static-to-meta/visitor.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const convertStaticToMeta: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, typeChecker: ts.TypeChecker, collection: d.CollectionCompilerMeta, transformOpts: d.TransformOptions) => ts.TransformerFactory<ts.SourceFile>;

package/dist/compiler/transformers/static-to-meta/watchers.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../../declarations';
+import ts from 'typescript';
+export declare const parseStaticWatchers: (staticMembers: ts.ClassElement[]) => d.ComponentCompilerWatch[];

package/dist/compiler/transformers/style-imports.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const updateStyleImports: (transformOpts: d.TransformOptions, tsSourceFile: ts.SourceFile, moduleFile: d.Module) => ts.SourceFile;

package/dist/compiler/transformers/transform-utils.d.ts

@@ -0,0 +1,31 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const getScriptTarget: () => ts.ScriptTarget;
+export declare const isMemberPrivate: (member: ts.ClassElement) => boolean;
+export declare const convertValueToLiteral: (val: any, refs?: WeakSet<any>) => ts.Identifier | ts.StringLiteral | ts.ObjectLiteralExpression | ts.ArrayLiteralExpression;
+export declare const createStaticGetter: (propName: string, returnExpression: ts.Expression) => ts.GetAccessorDeclaration;
+export declare const removeDecorators: (node: ts.Node, decoratorNames: Set<string>) => void;
+export declare const getStaticValue: (staticMembers: ts.ClassElement[], staticName: string) => any;
+export declare const arrayLiteralToArray: (arr: ts.ArrayLiteralExpression) => any[];
+export declare const objectLiteralToObjectMap: (objectLiteral: ts.ObjectLiteralExpression) => ObjectMap;
+export declare class ObjectMap {
+    [key: string]: ts.Expression | ObjectMap;
+}
+export declare const getAttributeTypeInfo: (baseNode: ts.Node, sourceFile: ts.SourceFile) => d.ComponentCompilerTypeReferences;
+export declare const validateReferences: (config: d.Config, diagnostics: d.Diagnostic[], references: d.ComponentCompilerTypeReferences, node: ts.Node) => void;
+export declare const resolveType: (checker: ts.TypeChecker, type: ts.Type) => string;
+export declare const typeToString: (checker: ts.TypeChecker, type: ts.Type) => string;
+export declare const parseDocsType: (checker: ts.TypeChecker, type: ts.Type, parts: Set<string>) => void;
+export declare const getModuleFromSourceFile: (compilerCtx: d.CompilerCtx, tsSourceFile: ts.SourceFile) => d.Module;
+export declare const getComponentMeta: (compilerCtx: d.CompilerCtx, tsSourceFile: ts.SourceFile, node: ts.ClassDeclaration) => d.ComponentCompilerMeta;
+export declare const getComponentTagName: (staticMembers: ts.ClassElement[]) => string;
+export declare const isStaticGetter: (member: ts.ClassElement) => boolean;
+export declare const serializeSymbol: (checker: ts.TypeChecker, symbol: ts.Symbol) => d.CompilerJsDoc;
+export declare const serializeDocsSymbol: (checker: ts.TypeChecker, symbol: ts.Symbol) => string;
+export declare const isInternal: (jsDocs: d.CompilerJsDoc) => boolean;
+export declare const isMethod: (member: ts.ClassElement, methodName: string) => member is ts.MethodDeclaration;
+export declare const isAsyncFn: (typeChecker: ts.TypeChecker, methodDeclaration: ts.MethodDeclaration) => boolean;
+export interface ConvertIdentifier {
+    __identifier: boolean;
+    __escapedText: string;
+}

package/dist/compiler/transformers/update-component-class.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const updateComponentClass: (transformOpts: d.TransformOptions, classNode: ts.ClassDeclaration, heritageClauses: ts.NodeArray<ts.HeritageClause> | ts.HeritageClause[], members: ts.ClassElement[]) => ts.VariableStatement | ts.ClassDeclaration;

package/dist/compiler/transformers/update-rindo-core-import.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export declare const updateRindoCoreImports: (updatedCoreImportPath: string) => ts.TransformerFactory<ts.SourceFile>;
+export declare const updateRindoCoreImport: (importNode: ts.ImportDeclaration, updatedCoreImportPath: string) => ts.ImportDeclaration;

package/dist/compiler/transformers/watcher-meta-transform.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare const addWatchers: (classMembers: ts.ClassElement[], cmp: d.ComponentCompilerMeta) => void;

package/dist/compiler/transpile/compiler-options.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+import ts from 'typescript';
+export declare function getUserCompilerOptions(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<any>;
+export declare const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions;

package/dist/compiler/transpile/transpile-app.d.ts

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

package/dist/compiler/transpile/transpile-module.d.ts

@@ -0,0 +1,5 @@
+import * as d from '../../declarations';
+/**
+ * Mainly used as the typescript preprocessor for unit tests
+ */
+export declare const transpileModule: (config: d.Config, input: string, transformOpts: d.TransformOptions, sourceFilePath?: string) => d.TranspileResults;

package/dist/compiler/transpile/transpile-service.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare const transpileService: (config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx) => Promise<boolean>;
+export declare const isFileIncludePath: (config: d.Config, readPath: string) => boolean;

package/dist/compiler/transpile/transpile-to-es5-main.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function transpileToEs5Main(config: d.Config, compilerCtx: d.CompilerCtx, input: string, inlineHelpers?: boolean): Promise<d.TranspileResults>;

package/dist/compiler/transpile/validate-types-main.d.ts

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

package/dist/compiler/types/generate-app-types.d.ts

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

package/dist/compiler/types/generate-component-types.d.ts

@@ -0,0 +1,8 @@
+import * as d from '../../declarations';
+/**
+ * Generate a string based on the types that are defined within a component.
+ *
+ * @param cmp the metadata for the component that a type definition string is generated for
+ * @param importPath the path of the component file
+ */
+export declare function generateComponentTypes(cmp: d.ComponentCompilerMeta): d.TypesModule;

package/dist/compiler/types/generate-event-types.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function generateEventTypes(cmpEvents: d.ComponentCompilerEvent[]): d.TypeInfo;

package/dist/compiler/types/generate-method-types.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function generateMethodTypes(cmpMethods: d.ComponentCompilerMethod[]): d.TypeInfo;

package/dist/compiler/types/generate-prop-types.d.ts

@@ -0,0 +1,2 @@
+import * as d from '../../declarations';
+export declare function generatePropTypes(cmpMeta: d.ComponentCompilerMeta): d.TypeInfo;

package/dist/compiler/types/generate-types.d.ts

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

package/dist/compiler/types/rindo-types.d.ts

@@ -0,0 +1,3 @@
+import * as d from '../../declarations';
+export declare function updateRindoTypesImports(path: d.Path, typesDir: string, dtsFilePath: string, dtsContent: string): string;
+export declare function copyRindoCoreDts(config: d.Config, compilerCtx: d.CompilerCtx): Promise<d.FsWriteResults[]>;

package/dist/compiler/types/types-utils.d.ts

@@ -0,0 +1,4 @@
+import * as d from '../../declarations';
+export declare const COMPONENTS_DTS_HEADER = "/* eslint-disable */\n/* tslint:disable */\n/**\n * This is an autogenerated file created by the Rindo compiler.\n * It contains typing information for all components that exist in this project.\n */";
+export declare function indentTypes(code: string): string;
+export declare function sortImportNames(a: d.TypesMemberNameData, b: d.TypesMemberNameData): 1 | 0 | -1;

package/dist/compiler/types/update-import-refs.d.ts

@@ -0,0 +1,11 @@
+import * as d from '../../declarations';
+/**
+ * Find all referenced types by a component and add them to the importDataObj and return the newly
+ * updated importDataObj
+ *
+ * @param importDataObj key/value of type import file, each value is an array of imported types
+ * @param cmpMeta the metadata for the component that is referencing the types
+ * @param filePath the path of the component file
+ * @param config general config that all of rindo uses
+ */
+export declare function updateReferenceTypeImports(config: d.Config, importDataObj: d.TypesImportData, allTypes: Map<string, number>, cmp: d.ComponentCompilerMeta, filePath: string): d.TypesImportData;

package/dist/compiler/types/validate-package-json.d.ts

@@ -0,0 +1,9 @@
+import * as d from '../../declarations';
+export declare function validatePackageJson(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): Promise<void>;
+export declare function validatePackageFiles(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, outputTarget: d.OutputTargetDistCollection): Promise<void>;
+export declare function validateMain(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, outputTarget: d.OutputTargetDistCollection): void;
+export declare function validateModule(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, outputTarget: d.OutputTargetDistCollection): void;
+export declare function validateTypes(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, outputTarget: d.OutputTargetDistTypes): Promise<void>;
+export declare function validateCollection(config: d.Config, compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx, outputTarget: d.OutputTargetDistCollection): void;
+export declare function validateBrowser(compilerCtx: d.CompilerCtx, buildCtx: d.BuildCtx): void;
+export declare function getRecommendedTypesPath(config: d.Config, outputTarget: d.OutputTargetDistTypes): string;

package/dist/declarations/assets.d.ts

@@ -0,0 +1,17 @@
+import { Diagnostic } from './diagnostics';
+export interface AssetsMeta {
+    absolutePath: string;
+    cmpRelativePath: string;
+    originalComponentPath: string;
+}
+export interface CopyTask {
+    src: string;
+    dest?: string;
+    warn?: boolean;
+    keepDirStructure?: boolean;
+}
+export interface CopyResults {
+    diagnostics: Diagnostic[];
+    filePaths: string[];
+    dirPaths: string[];
+}

package/dist/declarations/browser-compile.d.ts

@@ -0,0 +1,47 @@
+import { Diagnostic } from './diagnostics';
+export interface CompileOptions {
+    file?: string;
+    componentMetadata?: 'runtimestatic' | 'compilerstatic' | string | undefined;
+    proxy?: 'defineproperty' | string | undefined;
+    module?: 'cjs' | 'esm' | string;
+    componentExport?: 'customelement' | 'module' | string | undefined;
+    script?: CompileScript;
+    style?: 'static' | string | undefined;
+    type?: RindoDataType;
+    data?: RindoComponentData;
+}
+export interface CompileResults {
+    diagnostics: Diagnostic[];
+    code: string;
+    map: any;
+    inputFilePath: string;
+    outputFilePath: string;
+    inputOptions: CompileOptions;
+    imports: {
+        path: string;
+    }[];
+    componentMeta: any[];
+}
+export interface CompileScriptMinifyOptions {
+    script?: CompileScript;
+    pretty?: boolean;
+}
+export declare type CompileScript = 'latest' | 'esnext' | 'es2017' | 'es2015' | 'es5' | string | undefined;
+export declare type RindoDataType = 'css' | 'js' | 'ts' | 'tsx' | 'jsx' | 'dts';
+export interface ResolvedRindoData {
+    type: RindoDataType;
+    resolvedId: string;
+    resolvedFilePath: string;
+    resolvedFileName: string;
+    resolvedFileExt: string;
+    params: string;
+    data: RindoComponentData;
+    importee: string;
+    importer: string;
+    importerExt: string;
+}
+export interface RindoComponentData {
+    tag: string;
+    encapsulation?: string;
+    mode?: string;
+}

package/dist/declarations/build-conditionals.d.ts

@@ -0,0 +1,91 @@
+export interface BuildFeatures {
+    style: boolean;
+    mode: boolean;
+    shadowDom: boolean;
+    shadowDelegatesFocus: boolean;
+    scoped: boolean;
+    /**
+     * Every component has a render function
+     */
+    allRenderFn: boolean;
+    /**
+     * At least one component has a render function
+     */
+    hasRenderFn: boolean;
+    vdomRender: boolean;
+    noVdomRender: boolean;
+    vdomAttribute: boolean;
+    vdomClass: boolean;
+    vdomFunctional: boolean;
+    vdomKey: boolean;
+    vdomListener: boolean;
+    vdomRef: boolean;
+    vdomPropOrAttr: boolean;
+    vdomStyle: boolean;
+    vdomText: boolean;
+    vdomXlink: boolean;
+    slotRelocation: boolean;
+    slot: boolean;
+    svg: boolean;
+    element: boolean;
+    event: boolean;
+    hostListener: boolean;
+    hostListenerTargetWindow: boolean;
+    hostListenerTargetDocument: boolean;
+    hostListenerTargetBody: boolean;
+    hostListenerTargetParent: boolean;
+    hostListenerTarget: boolean;
+    method: boolean;
+    prop: boolean;
+    propMutable: boolean;
+    state: boolean;
+    watchCallback: boolean;
+    member: boolean;
+    updatable: boolean;
+    propBoolean: boolean;
+    propNumber: boolean;
+    propString: boolean;
+    lifecycle: boolean;
+    cmpDidLoad: boolean;
+    cmpShouldUpdate: boolean;
+    cmpWillLoad: boolean;
+    cmpDidUpdate: boolean;
+    cmpWillUpdate: boolean;
+    cmpWillRender: boolean;
+    cmpDidRender: boolean;
+    cmpDidUnload: boolean;
+    connectedCallback: boolean;
+    disconnectedCallback: boolean;
+    asyncLoading: boolean;
+    observeAttribute: boolean;
+    reflect: boolean;
+    taskQueue: boolean;
+}
+export interface Build extends Partial<BuildFeatures> {
+    hotModuleReplacement?: boolean;
+    isDebug?: boolean;
+    isTesting?: boolean;
+    isDev?: boolean;
+    devTools?: boolean;
+    hydrateServerSide?: boolean;
+    hydrateClientSide?: boolean;
+    lifecycleDOMEvents?: boolean;
+    cssAnnotations?: boolean;
+    lazyLoad?: boolean;
+    profile?: boolean;
+    cssVarShim?: boolean;
+    constructableCSS?: boolean;
+    appendChildSlotFix?: boolean;
+    cloneNodeFix?: boolean;
+    dynamicImportShim?: boolean;
+    hydratedAttribute?: boolean;
+    hydratedClass?: boolean;
+    initializeNextTick?: boolean;
+    safari10?: boolean;
+    scriptDataOpts?: boolean;
+    shadowDomShim?: boolean;
+}
+export interface UserBuildConditionals {
+    readonly isDev: boolean;
+    readonly isBrowser: boolean;
+}

package/dist/declarations/build-events.d.ts

@@ -0,0 +1,19 @@
+import { BuildLog, BuildNoChangeResults, BuildResults } from './build';
+import { FsWatchResults } from './fs-watch';
+export interface BuildEvents {
+    subscribe(eventName: 'fileUpdate', cb: (path: string) => void): Function;
+    subscribe(eventName: 'fileAdd', cb: (path: string) => void): Function;
+    subscribe(eventName: 'fileDelete', cb: (path: string) => void): Function;
+    subscribe(eventName: 'dirAdd', cb: (path: string) => void): Function;
+    subscribe(eventName: 'dirDelete', cb: (path: string) => void): Function;
+    subscribe(eventName: 'fsChange', cb: (fsWatchResults: FsWatchResults) => void): Function;
+    subscribe(eventName: 'buildFinish', cb: (buildResults: BuildResults) => void): Function;
+    subscribe(eventName: 'buildLog', cb: (buildLog: BuildLog) => void): Function;
+    unsubscribe(eventName: string, cb: Function): void;
+    unsubscribeAll(): void;
+    emit(eventName: 'buildNoChange', buildNoChange: BuildNoChangeResults): void;
+    emit(eventName: 'buildLog', buildLog: BuildLog): void;
+    emit(eventName: 'fsChange', fsWatchResults: FsWatchResults): void;
+    emit(eventName: CompilerEventName, ...args: any[]): void;
+}
+export declare type CompilerEventName = 'fileUpdate' | 'fileAdd' | 'fileDelete' | 'dirAdd' | 'dirDelete' | 'fsChange' | 'buildFinish' | 'buildNoChange' | 'buildLog';