create-docusaurus 0.0.0-4483 → 0.0.0-4487

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

@@ -1,357 +0,0 @@
-'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

@@ -1,153 +0,0 @@
-'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

@@ -1,9 +0,0 @@
-'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

@@ -1,11 +0,0 @@
-'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

@@ -1,24 +0,0 @@
-'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

@@ -1,119 +0,0 @@
-{
-  "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"
-  }
-}

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

@@ -1,19 +0,0 @@
-'use strict';
-
-const Input = require('postcss/lib/input');
-const TemplateParser = require('./template-parser');
-
-function templateParse(css, opts) {
-	const input = new Input(css, opts);
-
-	input.quasis = opts.quasis;
-	input.templateLiteralStyles = opts.templateLiteralStyles;
-	input.parseOptions = opts;
-	const parser = new TemplateParser(input);
-
-	parser.parse();
-
-	return parser.root;
-}
-
-module.exports = templateParse;