From 26105034da4fcce7ac883c899d781f016559310d Mon Sep 17 00:00:00 2001 From: ruki Date: Thu, 8 Nov 2018 00:38:48 +0800 Subject: switch to vuepress --- .../dist/compileStyle.d.ts | 25 +++++ .../component-compiler-utils/dist/compileStyle.js | 78 +++++++++++++++ .../dist/compileTemplate.d.ts | 22 +++++ .../dist/compileTemplate.js | 106 +++++++++++++++++++++ .../@vue/component-compiler-utils/dist/index.d.ts | 5 + .../@vue/component-compiler-utils/dist/index.js | 9 ++ .../@vue/component-compiler-utils/dist/parse.d.ts | 32 +++++++ .../@vue/component-compiler-utils/dist/parse.js | 53 +++++++++++ .../dist/stylePlugins/scoped.d.ts | 3 + .../dist/stylePlugins/scoped.js | 93 ++++++++++++++++++ .../dist/stylePlugins/trim.d.ts | 3 + .../dist/stylePlugins/trim.js | 10 ++ .../dist/styleProcessors/index.d.ts | 11 +++ .../dist/styleProcessors/index.js | 87 +++++++++++++++++ .../dist/templateCompilerModules/assetUrl.d.ts | 8 ++ .../dist/templateCompilerModules/assetUrl.js | 44 +++++++++ .../dist/templateCompilerModules/srcset.d.ts | 5 + .../dist/templateCompilerModules/srcset.js | 51 ++++++++++ .../dist/templateCompilerModules/utils.d.ts | 9 ++ .../dist/templateCompilerModules/utils.js | 44 +++++++++ .../@vue/component-compiler-utils/dist/types.d.ts | 30 ++++++ .../@vue/component-compiler-utils/dist/types.js | 2 + 22 files changed, 730 insertions(+) create mode 100644 node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/compileStyle.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/compileTemplate.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/index.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/index.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/parse.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/parse.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js create mode 100644 node_modules/@vue/component-compiler-utils/dist/types.d.ts create mode 100644 node_modules/@vue/component-compiler-utils/dist/types.js (limited to 'node_modules/@vue/component-compiler-utils/dist') diff --git a/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts b/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts new file mode 100644 index 00000000..078f5444 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/compileStyle.d.ts @@ -0,0 +1,25 @@ +import { LazyResult } from 'postcss'; +export interface StyleCompileOptions { + source: string; + filename: string; + id: string; + map?: any; + scoped?: boolean; + trim?: boolean; + preprocessLang?: string; + preprocessOptions?: any; + postcssOptions?: any; + postcssPlugins?: any[]; +} +export interface AsyncStyleCompileOptions extends StyleCompileOptions { + isAsync?: boolean; +} +export interface StyleCompileResults { + code: string; + map: any | void; + rawResult: LazyResult | void; + errors: string[]; +} +export declare function compileStyle(options: StyleCompileOptions): StyleCompileResults; +export declare function compileStyleAsync(options: StyleCompileOptions): Promise; +export declare function doCompileStyle(options: AsyncStyleCompileOptions): StyleCompileResults; diff --git a/node_modules/@vue/component-compiler-utils/dist/compileStyle.js b/node_modules/@vue/component-compiler-utils/dist/compileStyle.js new file mode 100644 index 00000000..f637c490 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/compileStyle.js @@ -0,0 +1,78 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const postcss = require('postcss'); +const trim_1 = require("./stylePlugins/trim"); +const scoped_1 = require("./stylePlugins/scoped"); +const styleProcessors_1 = require("./styleProcessors"); +function compileStyle(options) { + return doCompileStyle(Object.assign({}, options, { isAsync: false })); +} +exports.compileStyle = compileStyle; +function compileStyleAsync(options) { + return Promise.resolve(doCompileStyle(Object.assign({}, options, { isAsync: true }))); +} +exports.compileStyleAsync = compileStyleAsync; +function doCompileStyle(options) { + const { filename, id, scoped = true, trim = true, preprocessLang, postcssOptions, postcssPlugins } = options; + const preprocessor = preprocessLang && styleProcessors_1.processors[preprocessLang]; + const preProcessedSource = preprocessor && preprocess(options, preprocessor); + const map = preProcessedSource ? preProcessedSource.map : options.map; + const source = preProcessedSource ? preProcessedSource.code : options.source; + const plugins = (postcssPlugins || []).slice(); + if (trim) { + plugins.push(trim_1.default()); + } + if (scoped) { + plugins.push(scoped_1.default(id)); + } + const postCSSOptions = Object.assign({}, postcssOptions, { to: filename, from: filename }); + if (map) { + postCSSOptions.map = { + inline: false, + annotation: false, + prev: map + }; + } + let result, code, outMap; + const errors = []; + if (preProcessedSource && preProcessedSource.errors.length) { + errors.push(...preProcessedSource.errors); + } + try { + result = postcss(plugins).process(source, postCSSOptions); + // In async mode, return a promise. + if (options.isAsync) { + return result + .then((result) => ({ + code: result.css || '', + map: result.map && result.map.toJSON(), + errors, + rawResult: result + })) + .catch((error) => ({ + code: '', + map: undefined, + errors: [...errors, error.message], + rawResult: undefined + })); + } + // force synchronous transform (we know we only have sync plugins) + code = result.css; + outMap = result.map; + } + catch (e) { + errors.push(e); + } + return { + code: code || ``, + map: outMap && outMap.toJSON(), + errors, + rawResult: result + }; +} +exports.doCompileStyle = doCompileStyle; +function preprocess(options, preprocessor) { + return preprocessor.render(options.source, options.map, Object.assign({ + filename: options.filename + }, options.preprocessOptions)); +} diff --git a/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts new file mode 100644 index 00000000..8fa376ee --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.d.ts @@ -0,0 +1,22 @@ +import { VueTemplateCompiler, VueTemplateCompilerOptions } from './types'; +import { AssetURLOptions } from './templateCompilerModules/assetUrl'; +export interface TemplateCompileOptions { + source: string; + filename: string; + compiler: VueTemplateCompiler; + compilerOptions?: VueTemplateCompilerOptions; + transformAssetUrls?: AssetURLOptions | boolean; + preprocessLang?: string; + preprocessOptions?: any; + transpileOptions?: any; + isProduction?: boolean; + isFunctional?: boolean; + optimizeSSR?: boolean; +} +export interface TemplateCompileResult { + code: string; + source: string; + tips: string[]; + errors: string[]; +} +export declare function compileTemplate(options: TemplateCompileOptions): TemplateCompileResult; diff --git a/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js new file mode 100644 index 00000000..b958eb85 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/compileTemplate.js @@ -0,0 +1,106 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const assetUrl_1 = require("./templateCompilerModules/assetUrl"); +const srcset_1 = require("./templateCompilerModules/srcset"); +const prettier = require('prettier'); +const consolidate = require('consolidate'); +const transpile = require('vue-template-es2015-compiler'); +function compileTemplate(options) { + const { preprocessLang } = options; + const preprocessor = preprocessLang && consolidate[preprocessLang]; + if (preprocessor) { + return actuallyCompile(Object.assign({}, options, { + source: preprocess(options, preprocessor) + })); + } + else if (preprocessLang) { + return { + code: `var render = function () {}\n` + `var staticRenderFns = []\n`, + source: options.source, + tips: [ + `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.` + ], + errors: [ + `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.` + ] + }; + } + else { + return actuallyCompile(options); + } +} +exports.compileTemplate = compileTemplate; +function preprocess(options, preprocessor) { + const { source, filename, preprocessOptions } = options; + const finalPreprocessOptions = Object.assign({ + filename + }, preprocessOptions); + // Consolidate exposes a callback based API, but the callback is in fact + // called synchronously for most templating engines. In our case, we have to + // expose a synchronous API so that it is usable in Jest transforms (which + // have to be sync because they are applied via Node.js require hooks) + let res, err; + preprocessor.render(source, finalPreprocessOptions, (_err, _res) => { + if (_err) + err = _err; + res = _res; + }); + if (err) + throw err; + return res; +} +function actuallyCompile(options) { + const { source, compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false } = options; + const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile; + let finalCompilerOptions = compilerOptions; + if (transformAssetUrls) { + const builtInModules = [ + transformAssetUrls === true + ? assetUrl_1.default() + : assetUrl_1.default(transformAssetUrls), + srcset_1.default() + ]; + finalCompilerOptions = Object.assign({}, compilerOptions, { + modules: [...builtInModules, ...(compilerOptions.modules || [])] + }); + } + const { render, staticRenderFns, tips, errors } = compile(source, finalCompilerOptions); + if (errors && errors.length) { + return { + code: `var render = function () {}\n` + `var staticRenderFns = []\n`, + source, + tips, + errors + }; + } + else { + const finalTranspileOptions = Object.assign({}, transpileOptions, { + transforms: Object.assign({}, transpileOptions.transforms, { + stripWithFunctional: isFunctional + }) + }); + const toFunction = (code) => { + return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`; + }; + // transpile code with vue-template-es2015-compiler, which is a forked + // version of Buble that applies ES2015 transforms + stripping `with` usage + let code = transpile(`var __render__ = ${toFunction(render)}\n` + + `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`, finalTranspileOptions) + `\n`; + // #23 we use __render__ to avoid `render` not being prefixed by the + // transpiler when stripping with, but revert it back to `render` to + // maintain backwards compat + code = code.replace(/\s__(render|staticRenderFns)__\s/g, ' $1 '); + if (!isProduction) { + // mark with stripped (this enables Vue to use correct runtime proxy + // detection) + code += `render._withStripped = true`; + code = prettier.format(code, { semi: false, parser: 'babylon' }); + } + return { + code, + source, + tips, + errors + }; + } +} diff --git a/node_modules/@vue/component-compiler-utils/dist/index.d.ts b/node_modules/@vue/component-compiler-utils/dist/index.d.ts new file mode 100644 index 00000000..f7e9cf3e --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/index.d.ts @@ -0,0 +1,5 @@ +import { parse, SFCBlock, SFCCustomBlock, SFCDescriptor } from './parse'; +import { compileTemplate, TemplateCompileOptions, TemplateCompileResult } from './compileTemplate'; +import { compileStyle, compileStyleAsync, StyleCompileOptions, StyleCompileResults } from './compileStyle'; +export { parse, compileTemplate, compileStyle, compileStyleAsync }; +export { SFCBlock, SFCCustomBlock, SFCDescriptor, TemplateCompileOptions, TemplateCompileResult, StyleCompileOptions, StyleCompileResults }; diff --git a/node_modules/@vue/component-compiler-utils/dist/index.js b/node_modules/@vue/component-compiler-utils/dist/index.js new file mode 100644 index 00000000..a8f40555 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/index.js @@ -0,0 +1,9 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const parse_1 = require("./parse"); +exports.parse = parse_1.parse; +const compileTemplate_1 = require("./compileTemplate"); +exports.compileTemplate = compileTemplate_1.compileTemplate; +const compileStyle_1 = require("./compileStyle"); +exports.compileStyle = compileStyle_1.compileStyle; +exports.compileStyleAsync = compileStyle_1.compileStyleAsync; diff --git a/node_modules/@vue/component-compiler-utils/dist/parse.d.ts b/node_modules/@vue/component-compiler-utils/dist/parse.d.ts new file mode 100644 index 00000000..f82493e7 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/parse.d.ts @@ -0,0 +1,32 @@ +import { RawSourceMap, VueTemplateCompiler, VueTemplateCompilerParseOptions } from './types'; +export interface ParseOptions { + source: string; + filename?: string; + compiler: VueTemplateCompiler; + compilerParseOptions?: VueTemplateCompilerParseOptions; + sourceRoot?: string; + needMap?: boolean; +} +export interface SFCCustomBlock { + type: string; + content: string; + attrs: { + [key: string]: string | true; + }; + start: number; + end: number; + map?: RawSourceMap; +} +export interface SFCBlock extends SFCCustomBlock { + lang?: string; + src?: string; + scoped?: boolean; + module?: string | boolean; +} +export interface SFCDescriptor { + template: SFCBlock | null; + script: SFCBlock | null; + styles: SFCBlock[]; + customBlocks: SFCCustomBlock[]; +} +export declare function parse(options: ParseOptions): SFCDescriptor; diff --git a/node_modules/@vue/component-compiler-utils/dist/parse.js b/node_modules/@vue/component-compiler-utils/dist/parse.js new file mode 100644 index 00000000..17c95ae1 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/parse.js @@ -0,0 +1,53 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const hash = require('hash-sum'); +const cache = require('lru-cache')(100); +const { SourceMapGenerator } = require('source-map'); +const splitRE = /\r?\n/g; +const emptyRE = /^(?:\/\/)?\s*$/; +function parse(options) { + const { source, filename = '', compiler, compilerParseOptions = { pad: 'line' }, sourceRoot = process.cwd(), needMap = true } = options; + const cacheKey = hash(filename + source); + let output = cache.get(cacheKey); + if (output) + return output; + output = compiler.parseComponent(source, compilerParseOptions); + if (needMap) { + if (output.script && !output.script.src) { + output.script.map = generateSourceMap(filename, source, output.script.content, sourceRoot); + } + if (output.styles) { + output.styles.forEach(style => { + if (!style.src) { + style.map = generateSourceMap(filename, source, style.content, sourceRoot); + } + }); + } + } + cache.set(cacheKey, output); + return output; +} +exports.parse = parse; +function generateSourceMap(filename, source, generated, sourceRoot) { + const map = new SourceMapGenerator({ + file: filename, + sourceRoot + }); + map.setSourceContent(filename, source); + generated.split(splitRE).forEach((line, index) => { + if (!emptyRE.test(line)) { + map.addMapping({ + source: filename, + original: { + line: index + 1, + column: 0 + }, + generated: { + line: index + 1, + column: 0 + } + }); + } + }); + return map.toJSON(); +} diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts new file mode 100644 index 00000000..20c0dd03 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.d.ts @@ -0,0 +1,3 @@ +import * as postcss from 'postcss'; +declare const _default: postcss.Plugin; +export default _default; diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js new file mode 100644 index 00000000..e2dbd1a9 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/scoped.js @@ -0,0 +1,93 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const postcss = require("postcss"); +// postcss-selector-parser does have typings but it's problematic to work with. +const selectorParser = require('postcss-selector-parser'); +exports.default = postcss.plugin('add-id', (options) => (root) => { + const id = options; + const keyframes = Object.create(null); + root.each(function rewriteSelector(node) { + if (!node.selector) { + // handle media queries + if (node.type === 'atrule') { + if (node.name === 'media' || node.name === 'supports') { + node.each(rewriteSelector); + } + else if (/-?keyframes$/.test(node.name)) { + // register keyframes + keyframes[node.params] = node.params = node.params + '-' + id; + } + } + return; + } + node.selector = selectorParser((selectors) => { + selectors.each((selector) => { + let node = null; + selector.each((n) => { + // ">>>" combinator + if (n.type === 'combinator' && n.value === '>>>') { + n.value = ' '; + n.spaces.before = n.spaces.after = ''; + return false; + } + // /deep/ alias for >>>, since >>> doesn't work in SASS + if (n.type === 'tag' && n.value === '/deep/') { + const prev = n.prev(); + if (prev && prev.type === 'combinator' && prev.value === ' ') { + prev.remove(); + } + n.remove(); + return false; + } + if (n.type !== 'pseudo' && n.type !== 'combinator') { + node = n; + } + }); + if (node) { + node.spaces.after = ''; + } + else { + // For deep selectors & standalone pseudo selectors, + // the attribute selectors are prepended rather than appended. + // So all leading spaces must be eliminated to avoid problems. + selector.first.spaces.before = ''; + } + selector.insertAfter(node, selectorParser.attribute({ + attribute: id + })); + }); + }).processSync(node.selector); + }); + // If keyframes are found in this