diff options
Diffstat (limited to 'node_modules/@vue/component-compiler-utils/dist')
22 files changed, 730 insertions, 0 deletions
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<StyleCompileResults>; +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<any>; +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 <style>, find and rewrite animation names + // in declarations. + // Caveat: this only works for keyframes and animation rules in the same + // <style> element. + if (Object.keys(keyframes).length) { + root.walkDecls(decl => { + // individual animation-name declaration + if (/^(-\w+-)?animation-name$/.test(decl.prop)) { + decl.value = decl.value + .split(',') + .map(v => keyframes[v.trim()] || v.trim()) + .join(','); + } + // shorthand + if (/^(-\w+-)?animation$/.test(decl.prop)) { + decl.value = decl.value + .split(',') + .map(v => { + const vals = v.trim().split(/\s+/); + const i = vals.findIndex(val => keyframes[val]); + if (i !== -1) { + vals.splice(i, 1, keyframes[vals[i]]); + return vals.join(' '); + } + else { + return v; + } + }) + .join(','); + } + }); + } +}); diff --git a/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.d.ts new file mode 100644 index 00000000..ec36581c --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.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/trim.js b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js new file mode 100644 index 00000000..6895ce2f --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/stylePlugins/trim.js @@ -0,0 +1,10 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const postcss = require("postcss"); +exports.default = postcss.plugin('trim', () => (css) => { + css.walk(({ type, raws }) => { + if (type === 'rule' || type === 'atrule') { + raws.before = raws.after = '\n'; + } + }); +}); diff --git a/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts new file mode 100644 index 00000000..cc324a8c --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.d.ts @@ -0,0 +1,11 @@ +export interface StylePreprocessor { + render(source: string, map: any | null, options: any): StylePreprocessorResults; +} +export interface StylePreprocessorResults { + code: string; + map?: any; + errors: Array<Error>; +} +export declare const processors: { + [key: string]: StylePreprocessor; +}; diff --git a/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js new file mode 100644 index 00000000..430a83e2 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/styleProcessors/index.js @@ -0,0 +1,87 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const merge = require('merge-source-map'); +// .scss/.sass processor +const scss = { + render(source, map, options) { + const nodeSass = require('node-sass'); + const finalOptions = Object.assign({}, options, { + data: source, + file: options.filename, + outFile: options.filename, + sourceMap: !!map + }); + try { + const result = nodeSass.renderSync(finalOptions); + if (map) { + return { + code: result.css.toString(), + map: merge(map, JSON.parse(result.map.toString())), + errors: [] + }; + } + return { code: result.css.toString(), errors: [] }; + } + catch (e) { + return { code: '', errors: [e] }; + } + } +}; +const sass = { + render(source, map, options) { + return scss.render(source, map, Object.assign({}, options, { indentedSyntax: true })); + } +}; +// .less +const less = { + render(source, map, options) { + const nodeLess = require('less'); + let result; + let error = null; + nodeLess.render(source, Object.assign({}, options, { syncImport: true }), (err, output) => { + error = err; + result = output; + }); + if (error) + return { code: '', errors: [error] }; + if (map) { + return { + code: result.css.toString(), + map: merge(map, result.map), + errors: [] + }; + } + return { code: result.css.toString(), errors: [] }; + } +}; +// .styl +const styl = { + render(source, map, options) { + const nodeStylus = require('stylus'); + try { + const ref = nodeStylus(source); + Object.keys(options).forEach(key => ref.set(key, options[key])); + if (map) + ref.set('sourcemap', { inline: false, comment: false }); + const result = ref.render(); + if (map) { + return { + code: result, + map: merge(map, ref.sourcemap), + errors: [] + }; + } + return { code: result, errors: [] }; + } + catch (e) { + return { code: '', errors: [e] }; + } + } +}; +exports.processors = { + less, + sass, + scss, + styl, + stylus: styl +}; diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts new file mode 100644 index 00000000..5f7668e0 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.d.ts @@ -0,0 +1,8 @@ +import { ASTNode } from './utils'; +export interface AssetURLOptions { + [name: string]: string | string[]; +} +declare const _default: (userOptions?: AssetURLOptions | undefined) => { + postTransformNode: (node: ASTNode) => void; +}; +export default _default; diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js new file mode 100644 index 00000000..ef95f951 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/assetUrl.js @@ -0,0 +1,44 @@ +"use strict"; +// vue compiler module for transforming `<tag>:<attribute>` to `require` +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("./utils"); +const defaultOptions = { + video: ['src', 'poster'], + source: 'src', + img: 'src', + image: ['xlink:href', 'href'] +}; +exports.default = (userOptions) => { + const options = userOptions + ? Object.assign({}, defaultOptions, userOptions) + : defaultOptions; + return { + postTransformNode: (node) => { + transform(node, options); + } + }; +}; +function transform(node, options) { + for (const tag in options) { + if ((tag === '*' || node.tag === tag) && node.attrs) { + const attributes = options[tag]; + if (typeof attributes === 'string') { + node.attrs.some(attr => rewrite(attr, attributes)); + } + else if (Array.isArray(attributes)) { + attributes.forEach(item => node.attrs.some(attr => rewrite(attr, item))); + } + } + } +} +function rewrite(attr, name) { + if (attr.name === name) { + const value = attr.value; + // only transform static URLs + if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') { + attr.value = utils_1.urlToRequire(value.slice(1, -1)); + return true; + } + } + return false; +} diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts new file mode 100644 index 00000000..9c57ef90 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.d.ts @@ -0,0 +1,5 @@ +import { ASTNode } from './utils'; +declare const _default: () => { + postTransformNode: (node: ASTNode) => void; +}; +export default _default; diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js new file mode 100644 index 00000000..398d065e --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/srcset.js @@ -0,0 +1,51 @@ +"use strict"; +// vue compiler module for transforming `img:srcset` to a number of `require`s +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("./utils"); +exports.default = () => ({ + postTransformNode: (node) => { + transform(node); + } +}); +// http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5 +const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g; +function transform(node) { + const tags = ['img', 'source']; + if (tags.indexOf(node.tag) !== -1 && node.attrs) { + node.attrs.forEach(attr => { + if (attr.name === 'srcset') { + // same logic as in transform-require.js + const value = attr.value; + const isStatic = value.charAt(0) === '"' && value.charAt(value.length - 1) === '"'; + if (!isStatic) { + return; + } + const imageCandidates = value + .substr(1, value.length - 2) + .split(',') + .map(s => { + // The attribute value arrives here with all whitespace, except + // normal spaces, represented by escape sequences + const [url, descriptor] = s + .replace(escapedSpaceCharacters, ' ') + .trim() + .split(' ', 2); + return { require: utils_1.urlToRequire(url), descriptor }; + }); + // "require(url1)" + // "require(url1) 1x" + // "require(url1), require(url2)" + // "require(url1), require(url2) 2x" + // "require(url1) 1x, require(url2)" + // "require(url1) 1x, require(url2) 2x" + const code = imageCandidates + .map(({ require, descriptor }) => `${require} + "${descriptor ? ' ' + descriptor : ''}, " + `) + .join('') + .slice(0, -6) + .concat('"') + .replace(/ \+ ""$/, ''); + attr.value = code; + } + }); + } +} diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts new file mode 100644 index 00000000..f0b821ba --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.d.ts @@ -0,0 +1,9 @@ +export interface Attr { + name: string; + value: string; +} +export interface ASTNode { + tag: string; + attrs: Attr[]; +} +export declare function urlToRequire(url: string): string; diff --git a/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js new file mode 100644 index 00000000..71224c12 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/templateCompilerModules/utils.js @@ -0,0 +1,44 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const url_1 = require("url"); +function urlToRequire(url) { + const returnValue = `"${url}"`; + // same logic as in transform-require.js + const firstChar = url.charAt(0); + if (firstChar === '.' || firstChar === '~' || firstChar === '@') { + if (firstChar === '~') { + const secondChar = url.charAt(1); + url = url.slice(secondChar === '/' ? 2 : 1); + } + const uriParts = parseUriParts(url); + if (!uriParts.hash) { + return `require("${url}")`; + } + else { + // support uri fragment case by excluding it from + // the require and instead appending it as string; + // assuming that the path part is sufficient according to + // the above caseing(t.i. no protocol-auth-host parts expected) + return `require("${uriParts.path}") + "${uriParts.hash}"`; + } + } + return returnValue; +} +exports.urlToRequire = urlToRequire; +/** + * vuejs/component-compiler-utils#22 Support uri fragment in transformed require + * @param urlString an url as a string + */ +function parseUriParts(urlString) { + // initialize return value + const returnValue = url_1.parse(''); + if (urlString) { + // A TypeError is thrown if urlString is not a string + // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost + if ('string' === typeof urlString) { + // check is an uri + return url_1.parse(urlString); // take apart the uri + } + } + return returnValue; +} diff --git a/node_modules/@vue/component-compiler-utils/dist/types.d.ts b/node_modules/@vue/component-compiler-utils/dist/types.d.ts new file mode 100644 index 00000000..73aefd4b --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/types.d.ts @@ -0,0 +1,30 @@ +import { SFCDescriptor } from './parse'; +export interface StartOfSourceMap { + file?: string; + sourceRoot?: string; +} +export interface RawSourceMap extends StartOfSourceMap { + version: string; + sources: string[]; + names: string[]; + sourcesContent?: string[]; + mappings: string; +} +export interface VueTemplateCompiler { + parseComponent(source: string, options?: any): SFCDescriptor; + compile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults; + ssrCompile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults; +} +export interface VueTemplateCompilerOptions { + modules?: Object[]; +} +export interface VueTemplateCompilerParseOptions { + pad?: 'line' | 'space'; +} +export interface VueTemplateCompilerResults { + ast: Object | void; + render: string; + staticRenderFns: string[]; + errors: string[]; + tips: string[]; +} diff --git a/node_modules/@vue/component-compiler-utils/dist/types.js b/node_modules/@vue/component-compiler-utils/dist/types.js new file mode 100644 index 00000000..c8ad2e54 --- /dev/null +++ b/node_modules/@vue/component-compiler-utils/dist/types.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); |