create-docusaurus 0.0.0-4375 → 0.0.0-4379

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/literal.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Container = require('postcss/lib/container');
+
+/**
+ * Represents a JS literal
+ *
+ * @extends Container
+ *
+ * @example
+ * const root = postcss.parse('{}');
+ * const literal = root.first;
+ * literal.type       //=> 'literal'
+ * literal.toString() //=> 'a{}'
+ */
+class Literal extends Container {
+	constructor(defaults) {
+		super(defaults);
+		this.type = 'literal';
+	}
+}
+
+module.exports = Literal;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object-parse.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const Input = require('postcss/lib/input');
+const ObjectParser = require('./object-parser');
+
+function objectParse(source, opts) {
+	const input = new Input(source, opts);
+	const parser = new ObjectParser(input);
+
+	parser.parse(opts.node);
+
+	return parser.root;
+}
+
+module.exports = objectParse;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object-parser.js

@@ -0,0 +1,357 @@
+'use strict';
+
+const camelCase = require('./camel-case');
+const getTemplate = require('./get-template');
+const Literal = require('./literal');
+const ObjectLiteral = require('./object');
+const postcss = require('postcss');
+const unCamelCase = require('./un-camel-case');
+
+function forEach(arr, callback) {
+	arr && arr.forEach(callback);
+}
+
+const replaceProp = (fn) => (value) =>
+	value.replace(/(\(\s*)(.*?)(\s*:)/g, (s, prefix, prop, suffix) => prefix + fn(prop) + suffix);
+const camelCaseProp = replaceProp(camelCase);
+const unCamelCaseProp = replaceProp(unCamelCase);
+
+function defineRaws(node, prop, prefix, suffix, props) {
+	if (!props) {
+		props = {};
+	}
+
+	const descriptor = {
+		enumerable: true,
+		get: () => node[prop],
+		set: (value) => {
+			node[prop] = value;
+		},
+	};
+
+	if (!props.raw) {
+		props.raw = descriptor;
+	} else if (props.raw === 'camel') {
+		props.raw = {
+			enumerable: true,
+			get: () => camelCase(node[prop]),
+			set: (value) => {
+				node[prop] = unCamelCase(value);
+			},
+		};
+	}
+
+	props.value = descriptor;
+
+	node.raws[prop] = Object.defineProperties(
+		{
+			prefix,
+			suffix,
+		},
+		props,
+	);
+}
+
+class objectParser {
+	constructor(input) {
+		this.input = input;
+	}
+	parse(node) {
+		const root = postcss.root({
+			source: {
+				input: this.input,
+				start: node.loc.start,
+			},
+		});
+
+		root.raws.node = node;
+		const obj = new ObjectLiteral({
+			raws: {
+				node,
+			},
+		});
+
+		root.push(obj);
+		this.process(node, obj);
+		this.sort(root);
+		this.raws(root);
+
+		const startNode = root.first.raws.node;
+		const endNode = root.last.raws.node;
+
+		const start = {
+			line: startNode.loc.start.line,
+		};
+
+		let before = root.source.input.css.slice(
+			startNode.start - startNode.loc.start.column,
+			startNode.start,
+		);
+
+		if (/^\s+$/.test(before)) {
+			start.column = 1;
+		} else {
+			before = '';
+			start.column = startNode.loc.start.column;
+		}
+
+		root.first.raws.before = before;
+		root.source.input.css = before + root.source.input.css.slice(startNode.start, endNode.end);
+		root.source.start = start;
+
+		this.root = root;
+	}
+
+	process(node, parent) {
+		['leadingComments', 'innerComments', 'trailingComments'].forEach((prop) => {
+			forEach(node[prop], (child) => {
+				this.source(child, this.comment(child, parent));
+			});
+		});
+
+		const child = (this[node.type] || this.literal).apply(this, [node, parent]);
+
+		this.source(node, child);
+
+		return child;
+	}
+	source(node, parent) {
+		parent.source = {
+			input: this.input,
+			start: node.loc.start,
+			end: node.loc.end,
+		};
+
+		return parent;
+	}
+	raws(parent, node) {
+		const source = this.input.css;
+
+		parent.nodes.forEach((child, i) => {
+			if (i) {
+				child.raws.before = source
+					.slice(parent.nodes[i - 1].raws.node.end, child.raws.node.start)
+					.replace(/^\s*,+/, '');
+			} else if (node) {
+				child.raws.before = source.slice(node.start, child.raws.node.start).replace(/^\s*{+/, '');
+			}
+		});
+
+		if (node) {
+			let semicolon;
+			let after;
+
+			if (parent.nodes.length) {
+				after = source.slice(parent.last.raws.node.end, node.end).replace(/^\s*,+/, () => {
+					semicolon = true;
+
+					return '';
+				});
+			} else {
+				after = source.slice(node.start, node.end).replace(/^\s*{/, '');
+			}
+
+			parent.raws.after = after.replace(/}+\s*$/, '');
+			parent.raws.semicolon = semicolon || false;
+		}
+	}
+
+	sort(node) {
+		node.nodes = node.nodes.sort((a, b) => a.raws.node.start - b.raws.node.start);
+	}
+
+	getNodeValue(node, wrappedValue) {
+		const source = this.input.css;
+		let rawValue;
+		let cookedValue;
+
+		switch (node.type) {
+			case 'Identifier': {
+				const isCssFloat = node.name === 'cssFloat';
+
+				return {
+					prefix: '',
+					suffix: '',
+					raw: isCssFloat && node.name,
+					value: isCssFloat ? 'float' : node.name,
+				};
+			}
+			case 'StringLiteral': {
+				rawValue = node.extra.raw.slice(1, -1);
+				cookedValue = node.value;
+				break;
+			}
+			case 'TemplateLiteral': {
+				rawValue = getTemplate(node, source);
+				break;
+			}
+			default: {
+				rawValue = source.slice(node.start, node.end);
+				break;
+			}
+		}
+
+		const valueWrap = wrappedValue.split(rawValue);
+
+		return {
+			prefix: valueWrap[0],
+			suffix: valueWrap[1],
+			value: cookedValue || rawValue,
+		};
+	}
+
+	ObjectExpression(node, parent) {
+		forEach(node.properties, (child) => {
+			this.process(child, parent);
+		});
+		this.sort(parent);
+		this.raws(parent, node);
+
+		return parent;
+	}
+
+	ObjectProperty(node, parent) {
+		const source = this.input.css;
+		let between = source.indexOf(':', node.key.end);
+		const rawKey = source.slice(node.start, between).trimRight();
+		const rawValue = source.slice(between + 1, node.end).trimLeft();
+
+		between = source.slice(node.start + rawKey.length, node.end - rawValue.length);
+		const key = this.getNodeValue(node.key, rawKey);
+
+		if (node.value.type === 'ObjectExpression') {
+			let rule;
+
+			if (/^@(\S+)(\s*)(.*)$/.test(key.value)) {
+				const name = RegExp.$1;
+				const afterName = RegExp.$2;
+				const params = RegExp.$3;
+				const atRule = postcss.atRule({
+					name: unCamelCase(name),
+					raws: {
+						afterName,
+					},
+					nodes: [],
+				});
+
+				defineRaws(atRule, 'name', key.prefix + '@', params ? '' : key.suffix, {
+					raw: 'camel',
+				});
+
+				if (params) {
+					atRule.params = unCamelCaseProp(params);
+					defineRaws(atRule, 'params', '', key.suffix, {
+						raw: {
+							enumerable: true,
+							get: () => camelCaseProp(atRule.params),
+							set: (value) => {
+								atRule.params = unCamelCaseProp(value);
+							},
+						},
+					});
+				}
+
+				rule = atRule;
+			} else {
+				// rule = this.rule(key, keyWrap, node.value, parent);
+				rule = postcss.rule({
+					selector: key.value,
+				});
+				defineRaws(rule, 'selector', key.prefix, key.suffix);
+			}
+
+			raw(rule);
+			this.ObjectExpression(node.value, rule);
+
+			return rule;
+		}
+
+		const value = this.getNodeValue(node.value, rawValue);
+
+		if (key.value[0] === '@') {
+			const atRule = postcss.atRule({
+				name: unCamelCase(key.value),
+				params: value.value,
+			});
+
+			defineRaws(atRule, 'name', key.prefix, key.suffix, {
+				raw: 'camel',
+			});
+
+			defineRaws(atRule, 'params', value.prefix, value.suffix);
+			raw(atRule);
+
+			return atRule;
+		} else {
+			let decl;
+
+			if (key.raw) {
+				decl = postcss.decl({
+					prop: key.value,
+					value: value.value,
+					raws: {
+						prop: key,
+					},
+				});
+			} else {
+				decl = postcss.decl({
+					prop: unCamelCase(key.value),
+					value: value.value,
+				});
+
+				defineRaws(decl, 'prop', key.prefix, key.suffix, {
+					raw: 'camel',
+				});
+			}
+
+			defineRaws(decl, 'value', value.prefix, value.suffix);
+			raw(decl);
+
+			return decl;
+		}
+
+		function raw(postcssNode) {
+			postcssNode.raws.between = between;
+			postcssNode.raws.node = node;
+			parent.push(postcssNode);
+		}
+	}
+
+	literal(node, parent) {
+		const literal = new Literal({
+			text: this.input.css.slice(node.start, node.end),
+			raws: {
+				node,
+			},
+		});
+
+		parent.push(literal);
+
+		return literal;
+	}
+
+	comment(node, parent) {
+		if (
+			!parent.nodes ||
+			(node.start < parent.raws.node.start && parent.type !== 'root' && parent.parent)
+		) {
+			return this.comment(node, parent.parent);
+		}
+
+		const text = node.value.match(/^(\s*)((?:\S[\s\S]*?)?)(\s*)$/);
+		const comment = postcss.comment({
+			text: text[2],
+			raws: {
+				node,
+				left: text[1],
+				right: text[3],
+				inline: node.type === 'CommentLine',
+			},
+		});
+
+		parent.push(comment);
+
+		return comment;
+	}
+}
+module.exports = objectParser;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object-stringifier.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const camelCase = require('./camel-case');
+const Stringifier = require('postcss/lib/stringifier');
+
+class ObjectStringifier extends Stringifier {
+	object(node) {
+		this.builder('{', node, 'start');
+
+		let after;
+
+		if (node.nodes && node.nodes.length) {
+			this.body(node);
+			after = this.raw(node, 'after');
+		} else {
+			after = this.raw(node, 'after', 'emptyBody');
+		}
+
+		if (after) this.builder(after);
+
+		this.builder('}', node, 'end');
+	}
+	literal(node, semicolon) {
+		this.builder(node.text + (semicolon ? ',' : ''), node);
+	}
+	decl(node, semicolon) {
+		let prop = this.rawValue(node, 'prop');
+
+		if (prop === 'float') {
+			prop = 'cssFloat';
+		}
+
+		let string = prop;
+
+		const isObjectShorthand = node.raws.node && node.raws.node.shorthand;
+
+		if (!isObjectShorthand) {
+			const between = this.raw(node, 'between', 'colon');
+			const value = this.rawValue(node, 'value');
+
+			string += between + value;
+		}
+
+		if (semicolon) string += ',';
+
+		this.builder(string, node);
+	}
+	rule(node, semicolon) {
+		this.block(node, this.rawValue(node, 'selector'), semicolon);
+	}
+	atrule(node, semicolon) {
+		const name = this.rawValue(node, 'name');
+		const params = this.rawValue(node, 'params');
+
+		if (node.nodes) {
+			let string;
+
+			if (params) {
+				const afterName = this.raw(node, 'afterName');
+
+				string = name + afterName + params;
+			} else {
+				string = name;
+			}
+
+			this.block(node, string, semicolon);
+		} else {
+			const between = this.raw(node, 'between', 'colon');
+			let string = name + between + params;
+
+			if (semicolon) string += ',';
+
+			this.builder(string, node);
+		}
+	}
+	block(node, start, semicolon) {
+		super.block(node, start);
+
+		if (semicolon) {
+			this.builder(',', node);
+		}
+	}
+	comment(node) {
+		const left = this.raw(node, 'left', 'commentLeft');
+		const right = this.raw(node, 'right', 'commentRight');
+
+		if (node.raws.inline) {
+			const text = node.raws.text || node.text;
+
+			this.builder('//' + left + text + right, node);
+		} else {
+			this.builder('/*' + left + node.text + right + '*/', node);
+		}
+	}
+	raw(node, own, detect) {
+		let value = super.raw(node, own, detect);
+
+		if (
+			(own === 'between' || (own === 'afterName' && node.type === 'atrule' && !node.nodes)) &&
+			!/:/.test(value)
+		) {
+			value = ':' + value;
+		} else if (own === 'before' && /^(decl|rule)$/.test(node.type)) {
+			value = value.replace(/\S+$/, '');
+		}
+
+		return value;
+	}
+	rawValue(node, prop) {
+		const raw = node.raws[prop];
+
+		if (raw) {
+			const descriptor = Object.getOwnPropertyDescriptor(raw, 'raw');
+
+			if (descriptor && descriptor.get) {
+				return raw.prefix + raw.raw + raw.suffix;
+			}
+		}
+
+		let value = super.rawValue(node, prop);
+
+		if (value === null || value === undefined) {
+			return value;
+		}
+
+		if (/^(prop|selector)$/i.test(prop)) {
+			value = camelCase(value);
+
+			if (node.raws.before && /(\S+)$/.test(node.raws.before)) {
+				value = RegExp.$1 + value;
+			} else if (value && !/\W/.test(value)) {
+				return value;
+			}
+		} else if (node.type === 'atrule') {
+			if (prop === 'name') {
+				value = '@' + value;
+			} else if (node.nodes) {
+				return;
+			}
+
+			if (node.nodes) {
+				value += this.raw(node, 'afterName');
+				value += super.rawValue(node, 'params');
+			}
+		}
+
+		value = JSON.stringify(value);
+
+		return value;
+	}
+}
+
+module.exports = ObjectStringifier;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object-stringify.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const ObjectStringifier = require('./object-stringifier');
+
+module.exports = function objectStringify(node, builder) {
+	const str = new ObjectStringifier(builder);
+
+	str.stringify(node);
+};

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object-syntax.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const parse = require('./object-parse');
+const stringify = require('./object-stringify');
+
+const syntax = {
+	parse,
+	stringify,
+};
+
+module.exports = syntax;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/object.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Container = require('postcss/lib/container');
+
+/**
+ * Represents a JS Object Literal
+ *
+ * @extends Container
+ *
+ * @example
+ * const root = postcss.parse('{}');
+ * const obj = root.first;
+ * obj.type       //=> 'object'
+ * obj.toString() //=> '{}'
+ */
+class ObjectLiteral extends Container {
+	constructor(defaults) {
+		super(defaults);
+		this.type = 'object';
+		this.nodes = [];
+	}
+}
+
+module.exports = ObjectLiteral;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@stylelint/postcss-css-in-js",
+  "version": "0.37.2",
+  "description": "PostCSS syntax for parsing CSS in JS literals",
+  "keywords": [
+    "postcss",
+    "syntax",
+    "emotion",
+    "aphrodite",
+    "glamor",
+    "glamorous",
+    "react-native",
+    "react-style",
+    "reactcss",
+    "styled-components",
+    "styletron-react",
+    "typestyle",
+    "css-in-js",
+    "css"
+  ],
+  "repository": "stylelint/postcss-css-in-js",
+  "license": "MIT",
+  "author": "gucong3000",
+  "main": "index.js",
+  "files": [
+    "*.js"
+  ],
+  "scripts": {
+    "debug": "npm run mocha -- --inspect-brk",
+    "format": "prettier . --write",
+    "lint": "npm-run-all --parallel lint:*",
+    "lint:formatting": "prettier . --check",
+    "lint:js": "eslint . --cache --max-warnings=0",
+    "lint:md": "remark . --quiet --frail",
+    "mocha": "mocha --no-timeouts",
+    "release": "np",
+    "test": "nyc npm run mocha",
+    "watch": "mocha --watch"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.js": "eslint --cache --fix",
+    "*.{js,md,yml}": "prettier --write"
+  },
+  "prettier": "@stylelint/prettier-config",
+  "eslintConfig": {
+    "extends": [
+      "stylelint"
+    ],
+    "rules": {
+      "array-callback-return": "off",
+      "no-confusing-arrow": "off",
+      "no-else-return": "off",
+      "prefer--template": "off",
+      "prefer-object-spread": "off",
+      "prefer-rest-params": "off",
+      "prefer-spread": "off",
+      "prefer-template": "off",
+      "jest/expect-expect": "off",
+      "jest/valid-expect": "off"
+    }
+  },
+  "remarkConfig": {
+    "plugins": [
+      "@stylelint/remark-preset"
+    ]
+  },
+  "nyc": {
+    "all": true,
+    "cache": true,
+    "check-coverage": true,
+    "exclude": [
+      "coverage/**",
+      "test{,s}/**",
+      "**/.{prettier,eslint,mocha}rc.{js,cjs}"
+    ],
+    "reporter": [
+      "lcov",
+      "text"
+    ]
+  },
+  "dependencies": {
+    "@babel/core": ">=7.9.0"
+  },
+  "devDependencies": {
+    "@stylelint/prettier-config": "^2.0.0",
+    "@stylelint/remark-preset": "^1.0.0",
+    "autoprefixer": "^9.7.6",
+    "chai": "^4.2.0",
+    "codecov": "^3.6.5",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.10.1",
+    "eslint-config-stylelint": "^12.0.0",
+    "husky": "^4.2.5",
+    "json5": "^2.1.3",
+    "lint-staged": "^10.1.3",
+    "mocha": "^7.1.1",
+    "np": "^6.3.2",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^15.0.1",
+    "postcss": ">=7.0.27",
+    "postcss-parser-tests": "^6.5.0",
+    "postcss-safe-parser": "^4.0.2",
+    "postcss-syntax": ">=0.36.2",
+    "prettier": "^2.0.4",
+    "remark-cli": "^8.0.0"
+  },
+  "peerDependencies": {
+    "postcss": ">=7.0.0",
+    "postcss-syntax": ">=0.36.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}