[ 'bundle:umd:theme', 'bundle:umd:abc', 'bundle:umd:acl' ]);
+task('bump', bumpVersions);
+
+function bumpVersions() {
+ src([
+ './package.json',
+ './src/core/theme/package.json',
+ './src/core/abc/package.json',
+ './src/core/acl/package.json'], {base: './'})
+ .pipe(bump({
+ version: VERSION
+ }))
+ .pipe(dest('./'));
+}
+function copySources() {
+ src('./src/core/**/*')
+ .pipe(dest(paths.build))
+ .on('end', replaceLessWithCSS)
+ ;
+}
+
+function replaceLessWithCSS() {
+ src(`${paths.build}/**/*.ts`)
+ .pipe(replace('.less', '.css'))
+ .pipe(dest(paths.build))
+ .on('end', compileLess);
+}
+
+function compileLess() {
+ src([
+ `${paths.build}/**/*.less`,
+ `!${paths.build}/theme/styles/**/*.less`
+ ])
+ .pipe(less())
+ .pipe(dest(paths.build));
+}
+
+function copyResources() {
+ src([
+ `${paths.build}/**/*.html`,
+ `${paths.build}/**/*.css`,
+ `${paths.build}/**/*.less`,
+ `${paths.build}/**/LICENSE.txt`,
+ `${paths.build}/**/README.md`,
+ `${paths.build}/**/rollup.config.js`,
+ `${paths.build}/**/package.json`
+ ])
+ .pipe(dest(paths.lib))
+ .on('end', () => inline_recources(paths.lib));
+}
+
+function bundleUmdTheme() {
+ bundle(`${paths.lib}/theme/`);
+}
+
+function bundleUmdABC() {
+ bundle(`${paths.lib}/abc/`);
+}
+
+function bundleUmdACL() {
+ bundle(`${paths.lib}/acl/`);
+}
+
+function bundle(path: string) {
+ const config = require(`../../../${path}rollup.config.js`);
+ src(path + `**/*.js`)
+ .pipe(rollup(Object.assign({}, config, {
+ name: config.name,
+ input: `${path}index.js`
+ })))
+ .pipe(rename(config.output))
+ .pipe(dest(`${path}bundles`));
+}
diff --git a/tools/gulp/tasks/site.ts b/tools/gulp/tasks/site.ts
new file mode 100644
index 000000000..c09e79559
--- /dev/null
+++ b/tools/gulp/tasks/site.ts
@@ -0,0 +1,43 @@
+// tslint:disable
+import { task, src, dest } from 'gulp';
+import * as path from 'path';
+import * as fs from 'fs';
+import chalk from 'chalk';
+import { File, PluginError } from "gulp-util";
+import { gen } from '../utils/process';
+const del = require('del');
+const runSequence = require('run-sequence');
+const transform = require('gulp-transform');
+const htmlmin = require('gulp-htmlmin');
+const config = require('../../../site/site.config.js');
+// region: load template
+const tpl = {
+ doc: fs.readFileSync(`${config.theme.templates}/doc.ts`).toString('utf8'),
+ module: fs.readFileSync(`${config.theme.templates}/module.ts`).toString('utf8')
+};
+// endregion
+
+const allBuild: string[] = [];
+config.router.forEach((item: any) => {
+ const taskName = `site:build:${item.name}`;
+ if (!Array.isArray(item.src)) item.src = [ item.src ];
+ item.full_src = item.src.map((p: string) => path.normalize(p));
+ item.theme = config.theme;
+ item.tpl = tpl;
+
+ task(taskName, () => {
+ console.info(chalk.blue(`=====begin build: ${item.name}=====`));
+ const config = Object.assign({}, item);
+ src(config.src.map((p: string) => `${p}/**/*.md`))
+ .pipe(gen(config))
+ ;
+ });
+
+ // todo: test
+ // if (item.name === 'components')
+ allBuild.push(taskName);
+});
+
+task('site:build', (cb) => {
+ runSequence(allBuild);
+});
diff --git a/tools/gulp/tsconfig.json b/tools/gulp/tsconfig.json
new file mode 100644
index 000000000..94e72616d
--- /dev/null
+++ b/tools/gulp/tsconfig.json
@@ -0,0 +1,22 @@
+// TypeScript config file that will be used to compile the gulp tasks. The normal gulpfile will
+// use TS-Node to compile the gulp tasks at runtime.
+{
+ "compilerOptions": {
+ "experimentalDecorators": true,
+ "lib": ["es2015", "dom", "es2016.array.include"],
+ "module": "commonjs",
+ "moduleResolution": "node",
+ "outDir": "./dist",
+ "strictNullChecks": true,
+ "noEmitOnError": true,
+ "noImplicitAny": true,
+ "target": "es5",
+ "types": [
+ "node"
+ ],
+ "baseUrl": "."
+ },
+ "files": [
+ "gulpfile.ts"
+ ]
+}
diff --git a/tools/gulp/utils/inline-resources.js b/tools/gulp/utils/inline-resources.js
new file mode 100644
index 000000000..6ac3c47e7
--- /dev/null
+++ b/tools/gulp/utils/inline-resources.js
@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+/**
+ * Simple Promiseify function that takes a Node API and return a version that supports promises.
+ * We use promises instead of synchronized functions to make the process less I/O bound and
+ * faster. It also simplify the code.
+ */
+function promiseify(fn) {
+ return function () {
+ const args = [].slice.call(arguments, 0);
+ return new Promise((resolve, reject) => {
+ fn.apply(this, args.concat([function (err, value) {
+ if (err) {
+ reject(err);
+ } else {
+ resolve(value);
+ }
+ }]));
+ });
+ };
+}
+
+const readFile = promiseify(fs.readFile);
+const writeFile = promiseify(fs.writeFile);
+
+
+function inlineResources(globs) {
+ if (typeof globs == 'string') {
+ globs = [globs];
+ }
+
+ /**
+ * For every argument, inline the templates and styles under it and write the new file.
+ */
+ return Promise.all(globs.map(pattern => {
+ if (pattern.indexOf('*') < 0) {
+ // Argument is a directory target, add glob patterns to include every files.
+ pattern = path.join(pattern, '**', '*');
+ }
+
+ const files = glob.sync(pattern, {})
+ .filter(name => /\.js$/.test(name)); // Matches only JavaScript files.
+
+ // Generate all files content with inlined templates.
+ return Promise.all(files.map(filePath => {
+ return readFile(filePath, 'utf-8')
+ .then(content => inlineResourcesFromString(content, url => {
+ return path.join(path.dirname(filePath), url);
+ }))
+ .then(content => writeFile(filePath, content))
+ .catch(err => {
+ console.error('An error occurred: ', err);
+ });
+ }));
+ }));
+}
+
+/**
+ * Inline resources from a string content.
+ * @param content {string} The source file's content.
+ * @param urlResolver {Function} A resolver that takes a URL and return a path.
+ * @returns {string} The content with resources inlined.
+ */
+function inlineResourcesFromString(content, urlResolver) {
+ // Curry through the inlining functions.
+ return [
+ inlineTemplate,
+ inlineStyle,
+ removeModuleId
+ ].reduce((content, fn) => fn(content, urlResolver), content);
+}
+
+if (require.main === module) {
+ inlineResources(process.argv.slice(2));
+}
+
+
+/**
+ * Inline the templates for a source file. Simply search for instances of `templateUrl: ...` and
+ * replace with `template: ...` (with the content of the file included).
+ * @param content {string} The source file's content.
+ * @param urlResolver {Function} A resolver that takes a URL and return a path.
+ * @return {string} The content with all templates inlined.
+ */
+function inlineTemplate(content, urlResolver) {
+ return content.replace(/templateUrl:\s*'([^']+?\.html)'/g, function (m, templateUrl) {
+ const templateFile = urlResolver(templateUrl);
+ const templateContent = fs.readFileSync(templateFile, 'utf-8');
+ const shortenedTemplate = templateContent
+ .replace(/([\n\r]\s*)+/gm, ' ')
+ .replace(/"/g, '\\"');
+ return `template: "${shortenedTemplate}"`;
+ });
+}
+
+
+/**
+ * Inline the styles for a source file. Simply search for instances of `styleUrls: [...]` and
+ * replace with `styles: [...]` (with the content of the file included).
+ * @param urlResolver {Function} A resolver that takes a URL and return a path.
+ * @param content {string} The source file's content.
+ * @return {string} The content with all styles inlined.
+ */
+function inlineStyle(content, urlResolver) {
+ return content.replace(/styleUrls:\s*(\[[\s\S]*?\])/gm, function (m, styleUrls) {
+ const urls = eval(styleUrls);
+ return 'styles: [' +
+ urls.map(styleUrl => {
+ const styleFile = urlResolver(styleUrl);
+ const styleContent = fs.readFileSync(styleFile, 'utf-8');
+ const shortenedStyle = styleContent
+ .replace(/([\n\r]\s*)+/gm, ' ')
+ .replace(/"/g, '\\"');
+ return `"${shortenedStyle}"`;
+ })
+ .join(',\n') +
+ ']';
+ });
+}
+
+
+/**
+ * Remove every mention of `moduleId: module.id`.
+ * @param content {string} The source file's content.
+ * @returns {string} The content with all moduleId: mentions removed.
+ */
+function removeModuleId(content) {
+ return content.replace(/\s*moduleId:\s*module\.id\s*,?\s*/gm, '');
+}
+
+
+module.exports = inlineResources;
+module.exports.inlineResourcesFromString = inlineResourcesFromString;
diff --git a/tools/gulp/utils/process.ts b/tools/gulp/utils/process.ts
new file mode 100644
index 000000000..707b122e7
--- /dev/null
+++ b/tools/gulp/utils/process.ts
@@ -0,0 +1,379 @@
+// tslint:disable
+import chalk from 'chalk';
+import * as path from 'path';
+import * as fs from 'fs';
+import { highlight, site } from '../converters';
+import { toc } from '../plugins';
+import { isStandalone, getCode, escapeHTML } from '../utils/utils';
+const mkdirp = require('mkdirp');
+const through = require('through2');
+const MT = require('mark-twain');
+const mustache = require('mustache');
+const JsonML = require('jsonml.js/lib/utils');
+
+const converters = [
+ highlight()
+].concat(site()).concat([
+ [
+ (node: any) => typeof node === 'string',
+ (node: any) => node
+ ],
+ [
+ () => true,
+ (node: any) => {
+ const tagName = JsonML.getTagName(node);
+ const attrs = Object.assign({ }, JsonML.getAttributes(node));
+ return `${tagName ? `<${tagName}>` : ''}${isStandalone(tagName) ? '' : JsonML.getChildren(node).map(toHtml).join('')}${tagName ? `` : ''}`;
+ }
+ ]
+]);
+
+function toHtml(markdownData: any, codeEscape: boolean = true) {
+ const pair:any = converters.filter((converter: any) => {
+ return converter[0](markdownData);
+ })[0];
+ let ret: string = pair[1](markdownData);
+ if (codeEscape) {
+ return ret.replace(/([\s\S]*)<\/code><\/pre>/g, (fullWord: any, lang: any, code: any) => {
+ return `${escapeHTML(code)}
`;
+ });
+ }
+ return ret;
+}
+
+export function gen(config: any) {
+ const files: any[] = [];
+ const results: any[] = [];
+
+ function bufferContents(file: any, enc: any, cb: any) {
+ // ignore empty files
+ if (file.isNull()) {
+ cb();
+ return;
+ }
+
+ // ignore streams
+ if (file.isStream()) {
+ this.emit('error', new Error('Streaming not supported'));
+ cb();
+ return;
+ }
+
+ let mt: any = null;
+ try {
+ mt = MT(file.contents);
+ } catch (err) {
+ console.log(chalk.red(`markdown解析失败：${file.relative}`, err));
+ this.emit('error', new Error(`markdown解析失败：${file.relative}`));
+ cb();
+ return;
+ }
+
+ // todo: test
+ // if (file.path.indexOf('pro-header') === -1) {
+ // cb();
+ // return;
+ // }
+
+ // 同一目录下，不同语言文件解析至同一个对象中
+ const arr = file.relative.split(path.sep);
+ const nameArr = arr[0].split('.');
+ const name = nameArr[0] === `index` ? path.dirname(file.relative) : nameArr[0];
+ let item = files.find(w => w.path === file.base && w.name === name);
+ if (!item) {
+ item = {
+ data: {},
+ cwd: file.cwd,
+ path: file.base,
+ name: name,
+ i18n: nameArr.length === 3,
+ demos: []
+ };
+ files.push(item);
+ }
+ if (arr.indexOf('demo') === -1)
+ item.data[item.i18n ? nameArr[1] : config.theme.defaultLang] = mt;
+ else {
+ mt.name = arr[arr.length - 1].split('.')[0];
+ mt.source = path.relative(file.cwd, file.path).replace(new RegExp('\\' + path.sep, 'g'), '/');
+ item.demos.push(mt);
+ }
+
+ cb();
+ }
+
+ function convert() {
+ files.forEach((i: any) => {
+
+ for (const lang in i.data) {
+ const item = i.data[lang];
+ i.data[lang].toc = toc(item, config);
+ }
+
+ });
+
+ genMeta();
+ genPage();
+ }
+
+ function genMeta() {
+ const tpl = {
+ begin: `export const META: any = `,
+ end: `;`
+ };
+ config.theme.meta = `${config.theme.dist}/meta.ts`;
+ mkdirp.sync(path.dirname(config.theme.meta));
+ let metaContent = fs.readFileSync(config.theme.meta, { flag: 'a+' }).toString().trim();
+ if (metaContent.startsWith(tpl.begin))
+ metaContent = metaContent.substr(tpl.begin.length);
+ if (metaContent.endsWith(tpl.end))
+ metaContent = metaContent.substr(0, metaContent.length - tpl.end.length);
+ let json: any;
+ try {
+ json = JSON.parse(metaContent) || {};
+ } catch (err) {
+ json = {};
+ }
+ json.github = config.theme.github;
+ if (!json.types || !Array.isArray(json.types))
+ json.types = [];
+
+ let group = (json.types).find(w => w.name === config.name);
+ if (!group) {
+ group = {
+ name: config.name,
+ module: config.module,
+ types: config.types
+ };
+ json.types.push(group);
+ }
+ // clear all data
+ group.list = [];
+
+ files.forEach((i: any) => {
+ const langItem = i.data[config.theme.defaultLang];
+ if (!langItem) return;
+
+ const defLangMeta = langItem.meta || {};
+ const groupItem: any = {
+ name: i.name,
+ i18n: i.i18n,
+ module: config.module,
+ order: defLangMeta.order || 0,
+ cols: defLangMeta.cols || 1,
+ meta: {}
+ };
+
+ for (const lang in i.data) {
+ groupItem.meta[lang] = i.data[lang].meta;
+ const metaItem = Object.assign({}, i.data[lang].meta);
+ if (typeof metaItem.title === 'object') {
+ groupItem.meta[lang].title = '' + metaItem.title[lang];
+ if (!groupItem.i18n) {
+ for (const metaLang in metaItem.title) {
+ if (metaLang === lang) continue;
+ groupItem.meta[metaLang] = Object.assign({}, groupItem.meta[lang], {
+ title: metaItem.title[metaLang]
+ });
+ }
+ }
+ }
+ }
+
+ group.list.push(groupItem);
+ });
+
+ // group.list = group.list.sort((a: any, b: any) => a.order - b.order);
+
+ fs.writeFileSync(config.theme.meta, tpl.begin + JSON.stringify(json) + tpl.end);
+ }
+
+ function genUpperName(name: string) {
+ return name.split('-').map(v => v.charAt(0).toUpperCase() + v.slice(1)).join('');
+ }
+
+ function parseContent(markdownData: any, item: any) {
+ const contentChildren = JsonML.getChildren(markdownData.content);
+ const apiStartIndex = contentChildren.findIndex((node: any) =>
+ JsonML.getTagName(node) === 'h2' &&
+ /^API/.test(JsonML.getChildren(node)[0])
+ );
+
+ const ret: any = { };
+
+ if (apiStartIndex > -1) {
+ const content = contentChildren.slice(0, apiStartIndex);
+ ret.content = [''].concat(content);
+
+ const api = contentChildren.slice(apiStartIndex);
+ ret.api = [''].concat(api);
+ } else {
+ ret.content = markdownData.content;
+ }
+
+ if (ret.content)
+ ret.content = toHtml(ret.content);
+
+ if (ret.api)
+ ret.api = toHtml(ret.api);
+
+ return ret;
+ }
+
+ function genContentObject(i: any): any {
+ const ret: any = {
+ cols: i.data[config.theme.defaultLang].meta.cols,
+ source: {},
+ content: {},
+ toc: {}
+ };
+ const relPath = path.relative(i.cwd, i.path).replace(new RegExp('\\' + path.sep, 'g'), '/');
+
+ // i18n
+ if (i.i18n) {
+ for (const lang in i.data) {
+ ret.source[lang] = `${relPath}/${i.name}.${lang}.md`;
+ ret.content[lang] = parseContent(i.data[lang], i);
+ ret.toc[lang] = i.data[lang].toc;
+ }
+ } else {
+ ret.source = `${relPath}/${i.name}.md`;
+ ret.content[config.theme.defaultLang] = parseContent(i.data[config.theme.defaultLang], i);
+ ret.toc = i.data[config.theme.defaultLang].toc;
+ }
+
+ return ret;
+ }
+
+ function genDocFile(i: any) {
+ const content = mustache.render(config.tpl.doc, i);
+ const filePath = path.join(config.theme.dist, i.directoryName, i.name, `index.ts`);
+ mkdirp.sync(path.dirname(filePath));
+ fs.writeFileSync(filePath, content, { flag: 'w+' });
+ }
+
+ const modules: any = {
+ imports: [],
+ components: [],
+ routes: []
+ };
+
+ function appendToModule(componentName: string, name: string, filename: string = 'index', needRouter: boolean = true) {
+ modules.imports.push(`import { ${componentName} } from './${name}/${filename}';`);
+ modules.components.push(componentName);
+ if (needRouter) {
+ if (modules.routes.length <= 0 && config.defaultRoute) {
+ modules.routes.push(`{ path: '', redirectTo: '${config.defaultRoute}', pathMatch: 'full' }`);
+ }
+ modules.routes.push(`{ path: '${name}', component: ${componentName} }`);
+ }
+ }
+
+ function genModule(i: any) {
+ const content = mustache.render(config.tpl.module, i);
+ const filePath = path.join(config.theme.dist, i.name, `${i.name}.module.ts`);
+ mkdirp.sync(path.dirname(filePath));
+ fs.writeFileSync(filePath, content, { flag: 'w+' });
+ }
+
+ function genPage() {
+
+ const moduleName = genUpperName(config.name);
+
+ files.forEach((i: any) => {
+
+ // gen demo
+ const demos = genDemo(i);
+
+ const fileDataObj = genContentObject(i);
+ fileDataObj.demo = demos.tpl.length > 0;
+
+ const fileObj = {
+ name: i.name,
+ directoryName: config.name,
+ componentName: `${moduleName}${genUpperName(i.name)}Component`,
+ data: JSON.stringify(fileDataObj),
+ demos: demos.tpl.length > 0 ? `${demos.tpl.join('\r\n')}
` : '',
+ codes: JSON.stringify(demos.data)
+ };
+ // gen file
+ genDocFile(fileObj);
+ // append module
+ appendToModule(fileObj.componentName, fileObj.name);
+ });
+
+ const moduleObj = {
+ name: config.name,
+ moduleName: moduleName,
+ imports: modules.imports.join('\r\n'),
+ components: modules.components.join(',\r\n'),
+ routes: modules.routes.join(',\r\n')
+ };
+ genModule(moduleObj);
+ }
+
+ function genDemo(data: any): { tpl: string[], data: any[] } {
+ const ret: { tpl: string[], data: any[] } = {
+ tpl: [],
+ data: []
+ };
+ if (data.demos.length <= 0) return ret;
+ let point = 0;
+ data.demos.sort((a: any, b: any) => a.meta.order - b.meta.order).forEach((markdownData: any) => {
+ const item: any = {
+ id: `${config.name}-${data.name}-${markdownData.name}`,
+ meta: markdownData.meta,
+ source: markdownData.source,
+ lang: 'ts',
+ summary: ``,
+ code: ``
+ };
+
+ const contentChildren = JsonML.getChildren(markdownData.content);
+ const codeStartIndex = contentChildren.findIndex((node: any) => JsonML.getTagName(node) === 'pre');
+
+ if (codeStartIndex > -1) {
+ item.summary = toHtml([''].concat(contentChildren.slice(0, codeStartIndex)));
+
+ const codeNodes = contentChildren.slice(codeStartIndex);
+ if (codeNodes.length > 0) {
+ const attr = JsonML.getAttributes(codeNodes[0]);
+ item.code = getCode(codeNodes[0]);
+ item.lang = attr.lang;
+ }
+ } else {
+ item.summary = toHtml(markdownData.content);
+ }
+ ret.data.push(item);
+ // replace component name
+ const componentName = `${genUpperName(item.id)}Component`;
+ const code = ('' + item.code)
+ .replace(/selector:[ ]?(['|"|`])([^'"`]+)/g, `selector: $1${item.id}`)
+ .replace(/export class ([^ {]+)/g, `export class ${componentName}`);
+ // save demo component
+ const filePath = path.join(config.theme.dist, config.name, data.name, `${markdownData.name}.ts`);
+ mkdirp.sync(path.dirname(filePath));
+ fs.writeFileSync(filePath, code, { flag: 'w+' });
+ // generate doc component template
+ ret.tpl.push(`
+
+
+ <${item.id}>
+
+
`);
+ // import component
+ appendToModule(componentName, data.name, markdownData.name, false);
+
+ point++;
+ });
+ return ret;
+ }
+
+ function end(cb: any) {
+ convert();
+ this.push(...results);
+ cb();
+ }
+
+ return through.obj(bufferContents, end);
+}
diff --git a/tools/gulp/utils/utils.ts b/tools/gulp/utils/utils.ts
new file mode 100644
index 000000000..0abedf26a
--- /dev/null
+++ b/tools/gulp/utils/utils.ts
@@ -0,0 +1,57 @@
+// tslint:disable
+const JsonML = require('jsonml.js/lib/utils');
+
+export function isHeading(node: any) {
+ return /h[1-6]/i.test(typeof node === 'string' ? node : JsonML.getTagName(node));
+}
+
+export function isStandalone(tagName: string) {
+ return tagName === 'hr' || tagName === 'br' || tagName === 'img';
+}
+
+export function escapeHTML(str: string, escapeQuotes: boolean = false) {
+ if (!str || typeof str !== 'string') {
+ return '';
+ }
+
+ let escaped = str.replace(/&/g, '&')
+ .replace(//g, '>');
+
+ if (escapeQuotes) {
+ return escaped.replace(/"/g, '"').replace(/'/g, ''');
+ }
+
+ return escaped;
+}
+
+export function getCode(node: any) {
+ return JsonML.getChildren(JsonML.getChildren(node)[0] || '')[0] || '';
+}
+
+export function generateSluggedId(children: any): { id: string, text: string } {
+ const headingText = children.map((node: any) => {
+ if (JsonML.isElement(node)) {
+ if (JsonML.hasAttributes(node)) {
+ return node[2] || '';
+ }
+ return node[1] || '';
+ }
+ return node;
+ }).join('');
+ const sluggedId = headingText.trim().replace(/\s+/g, '-');
+ return {
+ id: sluggedId,
+ text: headingText
+ };
+}
+
+export function genAttr(attr: any) {
+ const ret: any[] = [];
+ if (attr) {
+ for (const key in attr) {
+ ret.push(`${key}="${attr[key]}"`);
+ }
+ }
+ return ret.join(' ');
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 000000000..8811fee00
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,26 @@
+{
+ "compileOnSave": false,
+ "compilerOptions": {
+ "outDir": "./dist/out-tsc",
+ "sourceMap": true,
+ "declaration": false,
+ "moduleResolution": "node",
+ "emitDecoratorMetadata": true,
+ "experimentalDecorators": true,
+ "target": "es5",
+ "typeRoots": [
+ "node_modules/@types"
+ ],
+ "lib": [
+ "es2017",
+ "dom"
+ ],
+ "baseUrl": "src/",
+ "paths": {
+ "@delon/*": [ "./core/*" ]
+ },
+ "plugins": [
+ { "name": "tslint-language-service"}
+ ]
+ }
+ }
diff --git a/tsconfig.publish.json b/tsconfig.publish.json
new file mode 100644
index 000000000..56ef778cb
--- /dev/null
+++ b/tsconfig.publish.json
@@ -0,0 +1,43 @@
+{
+ "compilerOptions": {
+ "declaration": true,
+ "emitDecoratorMetadata": true,
+ "experimentalDecorators": true,
+ "lib": [
+ "es7",
+ "dom"
+ ],
+ "module": "es2015",
+ "moduleResolution": "node",
+ "noEmitOnError": true,
+ "outDir": "./.lib",
+ "rootDir": "./.ng_build",
+ "sourceMap": true,
+ "target": "es5",
+ "inlineSources": true,
+ "stripInternal": true,
+ "baseUrl": ".",
+ "paths": {
+ "@delon/theme": ["./.ng_build/theme"]
+ },
+ "skipLibCheck": true,
+ "typeRoots": [
+ "node_modules/@types"
+ ]
+ },
+ "include": [
+ "./.ng_build/**/*"
+ ],
+ "files": [
+ "./src/typings.d.ts"
+ ],
+ "exclude": [
+ "./.ng_build/**/*.e2e.ts",
+ "./.ng_build/**/*.spec.ts"
+ ],
+ "angularCompilerOptions": {
+ "skipTemplateCodegen": true,
+ "strictMetadataEmit": true,
+ "genDir": "./.ng_compiled"
+ }
+ }
diff --git a/tslint.json b/tslint.json
new file mode 100644
index 000000000..dab6f55ec
--- /dev/null
+++ b/tslint.json
@@ -0,0 +1,141 @@
+{
+ "rulesDirectory": [
+ "node_modules/codelyzer"
+ ],
+ "rules": {
+ "arrow-return-shorthand": true,
+ "callable-types": true,
+ "class-name": true,
+ "comment-format": [
+ true,
+ "check-space"
+ ],
+ "curly": false,
+ "eofline": true,
+ "forin": true,
+ "import-blacklist": [
+ true,
+ "rxjs",
+ "rxjs/Rx"
+ ],
+ "import-spacing": true,
+ "indent": [
+ true,
+ "spaces"
+ ],
+ "interface-over-type-literal": true,
+ "label-position": true,
+ "max-line-length": [
+ false,
+ 140
+ ],
+ "member-access": false,
+ "member-ordering": [
+ false,
+ {
+ "order": [
+ "static-field",
+ "instance-field",
+ "static-method",
+ "instance-method"
+ ]
+ }
+ ],
+ "no-arg": true,
+ "no-bitwise": false,
+ "no-console": [
+ true,
+ "debug",
+ "info",
+ "time",
+ "timeEnd",
+ "trace"
+ ],
+ "no-construct": true,
+ "no-debugger": true,
+ "no-duplicate-super": true,
+ "no-empty": false,
+ "no-empty-interface": true,
+ "no-eval": true,
+ "no-inferrable-types": [
+ false,
+ "ignore-params"
+ ],
+ "no-misused-new": true,
+ "no-non-null-assertion": true,
+ "no-shadowed-variable": true,
+ "no-string-literal": false,
+ "no-string-throw": true,
+ "no-switch-case-fall-through": true,
+ "no-trailing-whitespace": false,
+ "no-unnecessary-initializer": true,
+ "no-unused-expression": true,
+ "no-use-before-declare": true,
+ "no-var-keyword": true,
+ "object-literal-sort-keys": false,
+ "one-line": [
+ true,
+ "check-open-brace",
+ "check-catch",
+ "check-else",
+ "check-whitespace"
+ ],
+ "prefer-const": true,
+ "quotemark": [
+ true,
+ "single"
+ ],
+ "radix": true,
+ "semicolon": [
+ true,
+ "always"
+ ],
+ "triple-equals": [
+ true,
+ "allow-null-check"
+ ],
+ "typedef-whitespace": [
+ true,
+ {
+ "call-signature": "nospace",
+ "index-signature": "nospace",
+ "parameter": "nospace",
+ "property-declaration": "nospace",
+ "variable-declaration": "nospace"
+ }
+ ],
+ "typeof-compare": true,
+ "unified-signatures": true,
+ "variable-name": false,
+ "whitespace": [
+ true,
+ "check-branch",
+ "check-decl",
+ "check-operator",
+ "check-separator",
+ "check-type"
+ ],
+ "directive-selector": [
+ false,
+ "attribute",
+ "app",
+ "camelCase"
+ ],
+ "component-selector": [
+ false,
+ "element",
+ "app",
+ "kebab-case"
+ ],
+ "use-input-property-decorator": true,
+ "use-output-property-decorator": true,
+ "use-host-property-decorator": false,
+ "no-input-rename": false,
+ "no-output-rename": false,
+ "use-life-cycle-interface": true,
+ "use-pipe-transform-interface": true,
+ "component-class-suffix": true,
+ "directive-class-suffix": true,
+ "invoke-injectable": true
+ }
+ }