Spaces:
Running
Running
| let { isClean, my } = require('./symbols') | |
| let Declaration = require('./declaration') | |
| let Comment = require('./comment') | |
| let Node = require('./node') | |
| let parse, Rule, AtRule | |
| function cleanSource(nodes) { | |
| return nodes.map(i => { | |
| if (i.nodes) i.nodes = cleanSource(i.nodes) | |
| delete i.source | |
| return i | |
| }) | |
| } | |
| function markDirtyUp(node) { | |
| node[isClean] = false | |
| if (node.proxyOf.nodes) { | |
| for (let i of node.proxyOf.nodes) { | |
| markDirtyUp(i) | |
| } | |
| } | |
| } | |
| class Container extends Node { | |
| push(child) { | |
| child.parent = this | |
| this.proxyOf.nodes.push(child) | |
| return this | |
| } | |
| each(callback) { | |
| if (!this.proxyOf.nodes) return undefined | |
| let iterator = this.getIterator() | |
| let index, result | |
| while (this.indexes[iterator] < this.proxyOf.nodes.length) { | |
| index = this.indexes[iterator] | |
| result = callback(this.proxyOf.nodes[index], index) | |
| if (result === false) break | |
| this.indexes[iterator] += 1 | |
| } | |
| delete this.indexes[iterator] | |
| return result | |
| } | |
| walk(callback) { | |
| return this.each((child, i) => { | |
| let result | |
| try { | |
| result = callback(child, i) | |
| } catch (e) { | |
| throw child.addToError(e) | |
| } | |
| if (result !== false && child.walk) { | |
| result = child.walk(callback) | |
| } | |
| return result | |
| }) | |
| } | |
| walkDecls(prop, callback) { | |
| if (!callback) { | |
| callback = prop | |
| return this.walk((child, i) => { | |
| if (child.type === 'decl') { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| if (prop instanceof RegExp) { | |
| return this.walk((child, i) => { | |
| if (child.type === 'decl' && prop.test(child.prop)) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| return this.walk((child, i) => { | |
| if (child.type === 'decl' && child.prop === prop) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| walkRules(selector, callback) { | |
| if (!callback) { | |
| callback = selector | |
| return this.walk((child, i) => { | |
| if (child.type === 'rule') { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| if (selector instanceof RegExp) { | |
| return this.walk((child, i) => { | |
| if (child.type === 'rule' && selector.test(child.selector)) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| return this.walk((child, i) => { | |
| if (child.type === 'rule' && child.selector === selector) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| walkAtRules(name, callback) { | |
| if (!callback) { | |
| callback = name | |
| return this.walk((child, i) => { | |
| if (child.type === 'atrule') { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| if (name instanceof RegExp) { | |
| return this.walk((child, i) => { | |
| if (child.type === 'atrule' && name.test(child.name)) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| return this.walk((child, i) => { | |
| if (child.type === 'atrule' && child.name === name) { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| walkComments(callback) { | |
| return this.walk((child, i) => { | |
| if (child.type === 'comment') { | |
| return callback(child, i) | |
| } | |
| }) | |
| } | |
| append(...children) { | |
| for (let child of children) { | |
| let nodes = this.normalize(child, this.last) | |
| for (let node of nodes) this.proxyOf.nodes.push(node) | |
| } | |
| this.markDirty() | |
| return this | |
| } | |
| prepend(...children) { | |
| children = children.reverse() | |
| for (let child of children) { | |
| let nodes = this.normalize(child, this.first, 'prepend').reverse() | |
| for (let node of nodes) this.proxyOf.nodes.unshift(node) | |
| for (let id in this.indexes) { | |
| this.indexes[id] = this.indexes[id] + nodes.length | |
| } | |
| } | |
| this.markDirty() | |
| return this | |
| } | |
| cleanRaws(keepBetween) { | |
| super.cleanRaws(keepBetween) | |
| if (this.nodes) { | |
| for (let node of this.nodes) node.cleanRaws(keepBetween) | |
| } | |
| } | |
| insertBefore(exist, add) { | |
| exist = this.index(exist) | |
| let type = exist === 0 ? 'prepend' : false | |
| let nodes = this.normalize(add, this.proxyOf.nodes[exist], type).reverse() | |
| for (let node of nodes) this.proxyOf.nodes.splice(exist, 0, node) | |
| let index | |
| for (let id in this.indexes) { | |
| index = this.indexes[id] | |
| if (exist <= index) { | |
| this.indexes[id] = index + nodes.length | |
| } | |
| } | |
| this.markDirty() | |
| return this | |
| } | |
| insertAfter(exist, add) { | |
| exist = this.index(exist) | |
| let nodes = this.normalize(add, this.proxyOf.nodes[exist]).reverse() | |
| for (let node of nodes) this.proxyOf.nodes.splice(exist + 1, 0, node) | |
| let index | |
| for (let id in this.indexes) { | |
| index = this.indexes[id] | |
| if (exist < index) { | |
| this.indexes[id] = index + nodes.length | |
| } | |
| } | |
| this.markDirty() | |
| return this | |
| } | |
| removeChild(child) { | |
| child = this.index(child) | |
| this.proxyOf.nodes[child].parent = undefined | |
| this.proxyOf.nodes.splice(child, 1) | |
| let index | |
| for (let id in this.indexes) { | |
| index = this.indexes[id] | |
| if (index >= child) { | |
| this.indexes[id] = index - 1 | |
| } | |
| } | |
| this.markDirty() | |
| return this | |
| } | |
| removeAll() { | |
| for (let node of this.proxyOf.nodes) node.parent = undefined | |
| this.proxyOf.nodes = [] | |
| this.markDirty() | |
| return this | |
| } | |
| replaceValues(pattern, opts, callback) { | |
| if (!callback) { | |
| callback = opts | |
| opts = {} | |
| } | |
| this.walkDecls(decl => { | |
| if (opts.props && !opts.props.includes(decl.prop)) return | |
| if (opts.fast && !decl.value.includes(opts.fast)) return | |
| decl.value = decl.value.replace(pattern, callback) | |
| }) | |
| this.markDirty() | |
| return this | |
| } | |
| every(condition) { | |
| return this.nodes.every(condition) | |
| } | |
| some(condition) { | |
| return this.nodes.some(condition) | |
| } | |
| index(child) { | |
| if (typeof child === 'number') return child | |
| if (child.proxyOf) child = child.proxyOf | |
| return this.proxyOf.nodes.indexOf(child) | |
| } | |
| get first() { | |
| if (!this.proxyOf.nodes) return undefined | |
| return this.proxyOf.nodes[0] | |
| } | |
| get last() { | |
| if (!this.proxyOf.nodes) return undefined | |
| return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] | |
| } | |
| normalize(nodes, sample) { | |
| if (typeof nodes === 'string') { | |
| nodes = cleanSource(parse(nodes).nodes) | |
| } else if (Array.isArray(nodes)) { | |
| nodes = nodes.slice(0) | |
| for (let i of nodes) { | |
| if (i.parent) i.parent.removeChild(i, 'ignore') | |
| } | |
| } else if (nodes.type === 'root' && this.type !== 'document') { | |
| nodes = nodes.nodes.slice(0) | |
| for (let i of nodes) { | |
| if (i.parent) i.parent.removeChild(i, 'ignore') | |
| } | |
| } else if (nodes.type) { | |
| nodes = [nodes] | |
| } else if (nodes.prop) { | |
| if (typeof nodes.value === 'undefined') { | |
| throw new Error('Value field is missed in node creation') | |
| } else if (typeof nodes.value !== 'string') { | |
| nodes.value = String(nodes.value) | |
| } | |
| nodes = [new Declaration(nodes)] | |
| } else if (nodes.selector) { | |
| nodes = [new Rule(nodes)] | |
| } else if (nodes.name) { | |
| nodes = [new AtRule(nodes)] | |
| } else if (nodes.text) { | |
| nodes = [new Comment(nodes)] | |
| } else { | |
| throw new Error('Unknown node type in node creation') | |
| } | |
| let processed = nodes.map(i => { | |
| /* c8 ignore next */ | |
| if (!i[my]) Container.rebuild(i) | |
| i = i.proxyOf | |
| if (i.parent) i.parent.removeChild(i) | |
| if (i[isClean]) markDirtyUp(i) | |
| if (typeof i.raws.before === 'undefined') { | |
| if (sample && typeof sample.raws.before !== 'undefined') { | |
| i.raws.before = sample.raws.before.replace(/\S/g, '') | |
| } | |
| } | |
| i.parent = this | |
| return i | |
| }) | |
| return processed | |
| } | |
| getProxyProcessor() { | |
| return { | |
| set(node, prop, value) { | |
| if (node[prop] === value) return true | |
| node[prop] = value | |
| if (prop === 'name' || prop === 'params' || prop === 'selector') { | |
| node.markDirty() | |
| } | |
| return true | |
| }, | |
| get(node, prop) { | |
| if (prop === 'proxyOf') { | |
| return node | |
| } else if (!node[prop]) { | |
| return node[prop] | |
| } else if ( | |
| prop === 'each' || | |
| (typeof prop === 'string' && prop.startsWith('walk')) | |
| ) { | |
| return (...args) => { | |
| return node[prop]( | |
| ...args.map(i => { | |
| if (typeof i === 'function') { | |
| return (child, index) => i(child.toProxy(), index) | |
| } else { | |
| return i | |
| } | |
| }) | |
| ) | |
| } | |
| } else if (prop === 'every' || prop === 'some') { | |
| return cb => { | |
| return node[prop]((child, ...other) => | |
| cb(child.toProxy(), ...other) | |
| ) | |
| } | |
| } else if (prop === 'root') { | |
| return () => node.root().toProxy() | |
| } else if (prop === 'nodes') { | |
| return node.nodes.map(i => i.toProxy()) | |
| } else if (prop === 'first' || prop === 'last') { | |
| return node[prop].toProxy() | |
| } else { | |
| return node[prop] | |
| } | |
| } | |
| } | |
| } | |
| getIterator() { | |
| if (!this.lastEach) this.lastEach = 0 | |
| if (!this.indexes) this.indexes = {} | |
| this.lastEach += 1 | |
| let iterator = this.lastEach | |
| this.indexes[iterator] = 0 | |
| return iterator | |
| } | |
| } | |
| Container.registerParse = dependant => { | |
| parse = dependant | |
| } | |
| Container.registerRule = dependant => { | |
| Rule = dependant | |
| } | |
| Container.registerAtRule = dependant => { | |
| AtRule = dependant | |
| } | |
| module.exports = Container | |
| Container.default = Container | |
| /* c8 ignore start */ | |
| Container.rebuild = node => { | |
| if (node.type === 'atrule') { | |
| Object.setPrototypeOf(node, AtRule.prototype) | |
| } else if (node.type === 'rule') { | |
| Object.setPrototypeOf(node, Rule.prototype) | |
| } else if (node.type === 'decl') { | |
| Object.setPrototypeOf(node, Declaration.prototype) | |
| } else if (node.type === 'comment') { | |
| Object.setPrototypeOf(node, Comment.prototype) | |
| } | |
| node[my] = true | |
| if (node.nodes) { | |
| node.nodes.forEach(child => { | |
| Container.rebuild(child) | |
| }) | |
| } | |
| } | |
| /* c8 ignore stop */ | |