create-docusaurus 0.0.0-4376 → 0.0.0-4383

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-docusaurus",
-  "version": "0.0.0-4376",
+  "version": "0.0.0-4383",
   "description": "Create Docusaurus apps easily.",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@docusaurus/logger": "0.0.0-4376",
+    "@docusaurus/logger": "0.0.0-4383",
     "commander": "^5.1.0",
     "fs-extra": "^10.0.0",
     "lodash": "^4.17.20",
@@ -39,5 +39,5 @@
   "devDependencies": {
     "@types/supports-color": "^8.1.1"
   },
-  "gitHead": "d95874b8c1ad60ed595d2088f23284df72903c29"
+  "gitHead": "6ccc0daea1a7b1413cd32f515a9e661c4007a355"
 }

package/templates/classic/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docusaurus-2-classic-template",
-  "version": "0.0.0-4376",
+  "version": "0.0.0-4383",
   "private": true,
   "scripts": {
     "docusaurus": "docusaurus",
@@ -14,8 +14,8 @@
     "write-heading-ids": "docusaurus write-heading-ids"
   },
   "dependencies": {
-    "@docusaurus/core": "0.0.0-4376",
-    "@docusaurus/preset-classic": "0.0.0-4376",
+    "@docusaurus/core": "0.0.0-4383",
+    "@docusaurus/preset-classic": "0.0.0-4383",
     "@mdx-js/react": "^1.6.21",
     "clsx": "^1.1.1",
     "prism-react-renderer": "^1.2.1",

package/templates/classic-typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docusaurus-2-classic-typescript-template",
-  "version": "0.0.0-4376",
+  "version": "0.0.0-4383",
   "private": true,
   "scripts": {
     "docusaurus": "docusaurus",
@@ -15,8 +15,8 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@docusaurus/core": "0.0.0-4376",
-    "@docusaurus/preset-classic": "0.0.0-4376",
+    "@docusaurus/core": "0.0.0-4383",
+    "@docusaurus/preset-classic": "0.0.0-4383",
     "@mdx-js/react": "^1.6.21",
     "clsx": "^1.1.1",
     "prism-react-renderer": "^1.2.1",
@@ -24,7 +24,7 @@
     "react-dom": "^17.0.1"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "0.0.0-4376",
+    "@docusaurus/module-type-aliases": "0.0.0-4383",
     "@tsconfig/docusaurus": "^1.0.4",
     "typescript": "^4.5.2"
   },

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

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.37.2
+
+- Fixed: use HTTPS url instead of HTTP for postcss logo in README ([#39](https://github.com/stylelint/postcss-css-in-js/pull/39)).
+
+## 0.37.1
+
+- Fixed: maximum call stack size exceeded error ([#31](https://github.com/stylelint/postcss-css-in-js/pull/31)).
+
+## 0.37.0
+
+- Fixed: babel configuration conflict when using TypeScript ([#2](https://github.com/stylelint/postcss-css-in-js/pull/2)).
+- Fixed: parsing/stringifying for nested tagged template literals ([#17](https://github.com/stylelint/postcss-css-in-js/pull/17)).
+
+## Previous changes
+
+See [postcss-jsx releases](https://github.com/gucong3000/postcss-jsx/releases).

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 刘祺
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,91 @@
+# PostCSS CSS-in-JS Syntax
+
+[![NPM version](https://img.shields.io/npm/v/@stylelint/postcss-css-in-js.svg)](https://www.npmjs.org/package/@stylelint/postcss-css-in-js) [![Build Status](https://github.com/stylelint/postcss-css-in-js/workflows/CI/badge.svg)](https://github.com/stylelint/postcss-css-in-js/actions)
+
+<img align="right" width="95" height="95"
+	title="Philosopher’s stone, logo of PostCSS"
+	src="https://api.postcss.org/logo.svg">
+
+[PostCSS](https://github.com/postcss/postcss) syntax for parsing [CSS in JS](https://github.com/MicheleBertoli/css-in-js) literals:
+
+- [aphrodite](https://github.com/Khan/aphrodite)
+- [astroturf](https://github.com/4Catalyzer/astroturf)
+- [csjs](https://github.com/rtsao/csjs)
+- [css-light](https://github.com/streamich/css-light)
+- [cssobj](https://github.com/cssobj/cssobj)
+- [electron-css](https://github.com/azukaar/electron-css)
+- [emotion](https://github.com/emotion-js/emotion)
+- [freestyler](https://github.com/streamich/freestyler)
+- [glamor](https://github.com/threepointone/glamor)
+- [glamorous](https://github.com/paypal/glamorous)
+- [j2c](https://github.com/j2css/j2c)
+- [linaria](https://github.com/callstack/linaria)
+- [lit-css](https://github.com/bashmish/lit-css)
+- [react-native](https://github.com/necolas/react-native-web)
+- [react-style](https://github.com/js-next/react-style)
+- [reactcss](https://github.com/casesandberg/reactcss)
+- [styled-components](https://github.com/styled-components/styled-components)
+- [styletron-react](https://github.com/rtsao/styletron)
+- [styling](https://github.com/andreypopp/styling)
+- [typestyle](https://github.com/typestyle/typestyle)
+
+## Getting Started
+
+First thing's first, install the module:
+
+```
+npm install postcss-syntax @stylelint/postcss-css-in-js --save-dev
+```
+
+## Use Cases
+
+```js
+const postcss = require("postcss");
+const stylelint = require("stylelint");
+const syntax = require("postcss-syntax");
+postcss([stylelint({ fix: true })])
+  .process(source, { syntax: syntax })
+  .then(function (result) {
+    // An alias for the result.css property. Use it with syntaxes that generate non-CSS output.
+    result.content;
+  });
+```
+
+input:
+
+```javascript
+import glm from "glamorous";
+const Component1 = glm.a({
+  flexDirectionn: "row",
+  display: "inline-block",
+  color: "#fff"
+});
+```
+
+output:
+
+```javascript
+import glm from "glamorous";
+const Component1 = glm.a({
+  color: "#fff",
+  display: "inline-block",
+  flexDirectionn: "row"
+});
+```
+
+## Advanced Use Cases
+
+Add support for more `css-in-js` package:
+
+```js
+const syntax = require("postcss-syntax")({
+  "i-css": (index, namespace) => namespace[index + 1] === "addStyles",
+  "styled-components": true
+});
+```
+
+See: [postcss-syntax](https://github.com/gucong3000/postcss-syntax)
+
+## Style Transformations
+
+The main use case of this plugin is to apply PostCSS transformations to CSS code in template literals & styles as object literals.

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

@@ -0,0 +1,13 @@
+'use strict';
+
+function camelCase(str) {
+	return str.replace(/[\w-]+/g, (s) =>
+		/^-?[a-z]+(?:-[a-z]+)+$/.test(s)
+			? s
+					.replace(/^-(ms|moz|khtml|epub|(\w+-?)*webkit)(?=-)/i, '$1')
+					.replace(/-\w/g, (s) => s[1].toUpperCase())
+			: s,
+	);
+}
+
+module.exports = camelCase;

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

@@ -0,0 +1,462 @@
+'use strict';
+
+const getTemplate = require('./get-template');
+const loadSyntax = require('postcss-syntax/load-syntax');
+const { parse, types, traverse, loadOptions } = require('@babel/core');
+
+const isStyleSheetCreate = expectAdjacentSibling(['create']);
+const supports = {
+	// import styled from '@emotion/styled'
+	// import { styled } from 'glamor/styled'
+	// import { styled } from "styletron-react";
+	// import { styled } from 'linaria/react';
+	// import { styled } from '@material-ui/styles'
+	styled: true,
+
+	// import { style } from "typestyle";
+	style: true,
+
+	// import { StyleSheet, css } from 'aphrodite';
+	// import styled, { css } from 'astroturf';
+	// import { css } from 'lit-css';
+	// import { css } from 'glamor'
+	// require('css-light').css({color: 'red'});
+	// import { css } from 'linaria';
+	css: true,
+
+	// import { StyleSheet, css } from 'aphrodite';
+	// import { AppRegistry, StyleSheet, Text, View } from 'react-native';
+	StyleSheet: isStyleSheetCreate,
+
+	// import styled, { css } from 'astroturf';
+	astroturf: true,
+
+	// require('csjs')`css`;
+	csjs: true,
+
+	// require('cssobj')({color: 'red'})
+	cssobj: true,
+
+	// require('electron-css')({color: 'red'})
+	'electron-css': true,
+
+	// import styled from "react-emotion";
+	'react-emotion': true,
+
+	// import styled from 'preact-emotion'
+	'preact-emotion': true,
+
+	// https://github.com/streamich/freestyler
+	freestyler: true,
+
+	// https://github.com/paypal/glamorous
+	glamorous: true,
+
+	// https://github.com/irom-io/i-css
+	// "i-css": (i, nameSpace) => nameSpace[i + 1] === "addStyles" && nameSpace[i + 2] === "wrapper",
+
+	// https://github.com/j2css/j2c
+	j2c: expectAdjacentSibling(['inline', 'sheet']),
+
+	// var styles = StyleSheet.create({color: 'red'})
+	'react-inline': isStyleSheetCreate,
+	'react-style': isStyleSheetCreate,
+
+	// import reactCSS from 'reactcss'
+	reactcss: true,
+
+	// const StyledButton = injectSheet(styles)(Button)
+	'react-jss': true,
+
+	// import styled from 'styled-components';
+	'styled-components': true,
+
+	// import {withStyle} from "styletron-react";
+	'styletron-react': expectAdjacentSibling(['withStyle']),
+
+	styling: true,
+
+	// const rule = superstyle({ color: 'blue' })
+	superstyle: true,
+
+	// import { makeStyles } from '@material-ui/styles'
+	styles: expectAdjacentSibling(['makeStyles']),
+};
+
+const plugins = [
+	'jsx',
+	'typescript',
+	'objectRestSpread',
+	['decorators', { decoratorsBeforeExport: false }],
+	'classProperties',
+	'exportExtensions',
+	'asyncGenerators',
+	'functionBind',
+	'functionSent',
+	'dynamicImport',
+	'optionalCatchBinding',
+];
+
+function expectAdjacentSibling(names) {
+	return (i, nameSpace) => names.some((name) => nameSpace[i + 1] === name);
+}
+
+function loadBabelOpts(opts) {
+	const filename = opts.from && opts.from.replace(/\?.*$/, '');
+
+	opts = {
+		filename,
+		parserOpts: {
+			plugins,
+			sourceFilename: filename,
+			sourceType: filename && /\.m[tj]sx?$/.test(filename) ? 'module' : 'unambiguous',
+			allowImportExportEverywhere: true,
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+		},
+	};
+	let fileOpts;
+
+	try {
+		fileOpts =
+			filename &&
+			loadOptions({
+				filename,
+			});
+	} catch (ex) {
+		//
+	}
+
+	for (const key in fileOpts) {
+		if (Array.isArray(fileOpts[key]) && !fileOpts[key].length) {
+			continue;
+		}
+
+		opts[key] = fileOpts[key];
+
+		if (Array.isArray(fileOpts[key]) && Array.isArray(opts.parserOpts[key])) {
+			// combine arrays for plugins
+			opts.parserOpts[key] = opts.parserOpts[key].concat(fileOpts[key]);
+		} else {
+			// because some options need to be passed to parser also
+			opts.parserOpts[key] = fileOpts[key];
+		}
+	}
+
+	return opts;
+}
+
+function literalParser(source, opts, styles) {
+	let ast;
+
+	try {
+		ast = parse(source, loadBabelOpts(opts));
+	} catch (ex) {
+		// console.error(ex);
+		return styles || [];
+	}
+
+	const specifiers = new Map();
+	const variableDeclarator = new Map();
+	const objLiteral = new Set();
+	const tplLiteral = new Set();
+	const tplCallee = new Set();
+	const jobs = [];
+
+	function addObjectJob(path) {
+		jobs.push(() => {
+			addObjectValue(path);
+		});
+	}
+
+	function addObjectValue(path) {
+		if (path.isIdentifier()) {
+			const identifier = path.scope.getBindingIdentifier(path.node.name);
+
+			if (identifier) {
+				path = variableDeclarator.get(identifier);
+
+				if (path) {
+					variableDeclarator.delete(identifier);
+					path.forEach(addObjectExpression);
+				}
+			}
+		} else {
+			addObjectExpression(path);
+		}
+	}
+
+	function addObjectExpression(path) {
+		if (path.isObjectExpression()) {
+			path.get('properties').forEach((prop) => {
+				if (prop.isSpreadElement()) {
+					addObjectValue(prop.get('argument'));
+				}
+			});
+			objLiteral.add(path.node);
+
+			return path;
+		}
+	}
+
+	function setSpecifier(id, nameSpace) {
+		nameSpace.unshift(
+			...nameSpace
+				.shift()
+				.replace(/^\W+/, '')
+				.split(/[/\\]+/g),
+		);
+
+		if (types.isIdentifier(id)) {
+			specifiers.set(id.name, nameSpace);
+			specifiers.set(id, nameSpace);
+		} else if (types.isObjectPattern(id)) {
+			id.properties.forEach((property) => {
+				if (types.isObjectProperty(property)) {
+					const key = property.key;
+
+					nameSpace = nameSpace.concat(key.name || key.value);
+					id = property.value;
+				} else {
+					id = property.argument;
+				}
+
+				setSpecifier(id, nameSpace);
+			});
+		} else if (types.isArrayPattern(id)) {
+			id.elements.forEach((element, i) => {
+				setSpecifier(element, nameSpace.concat(String(i)));
+			});
+		}
+	}
+
+	function getNameSpace(path, nameSpace) {
+		let node = path.node;
+
+		if (path.isIdentifier() || path.isJSXIdentifier()) {
+			node = path.scope.getBindingIdentifier(node.name) || node;
+			const specifier = specifiers.get(node) || specifiers.get(node.name);
+
+			if (specifier) {
+				nameSpace.unshift(...specifier);
+			} else {
+				nameSpace.unshift(node.name);
+			}
+		} else {
+			['name', 'property', 'object', 'callee'].forEach((prop) => {
+				node[prop] && getNameSpace(path.get(prop), nameSpace);
+			});
+		}
+
+		return nameSpace;
+	}
+
+	function isStylePath(path) {
+		return getNameSpace(path, []).some(function (name, ...args) {
+			const result =
+				name &&
+				((Object.prototype.hasOwnProperty.call(supports, name) && supports[name]) ||
+					(Object.prototype.hasOwnProperty.call(opts.syntax.config, name) &&
+						opts.syntax.config[name]));
+
+			switch (typeof result) {
+				case 'function': {
+					return result.apply(this, args);
+				}
+				case 'boolean': {
+					return result;
+				}
+				default: {
+					return undefined;
+				}
+			}
+		});
+	}
+
+	const visitor = {
+		ImportDeclaration: (path) => {
+			const moduleId = path.node.source.value;
+
+			path.node.specifiers.forEach((specifier) => {
+				const nameSpace = [moduleId];
+
+				if (specifier.imported) {
+					nameSpace.push(specifier.imported.name);
+				}
+
+				setSpecifier(specifier.local, nameSpace);
+			});
+		},
+		JSXAttribute: (path) => {
+			if (/^(?:css|style)$/.test(path.node.name.name)) {
+				addObjectJob(path.get('value.expression'));
+			}
+		},
+		VariableDeclarator: (path) => {
+			variableDeclarator.set(path.node.id, path.node.init ? [path.get('init')] : []);
+		},
+		AssignmentExpression: (path) => {
+			if (types.isIdentifier(path.node.left) && types.isObjectExpression(path.node.right)) {
+				const identifier = path.scope.getBindingIdentifier(path.node.left.name);
+				const variable = variableDeclarator.get(identifier);
+				const valuePath = path.get('right');
+
+				if (variable) {
+					variable.push(valuePath);
+				} else {
+					variableDeclarator.set(identifier, [valuePath]);
+				}
+			}
+		},
+		CallExpression: (path) => {
+			const callee = path.node.callee;
+
+			if (
+				types.isIdentifier(callee, { name: 'require' }) &&
+				!path.scope.getBindingIdentifier(callee.name)
+			) {
+				path.node.arguments.filter(types.isStringLiteral).forEach((arg) => {
+					const moduleId = arg.value;
+					const nameSpace = [moduleId];
+					let currPath = path;
+
+					do {
+						let id = currPath.parent.id;
+
+						if (!id) {
+							id = currPath.parent.left;
+
+							if (id) {
+								id = path.scope.getBindingIdentifier(id.name) || id;
+							} else {
+								if (types.isIdentifier(currPath.parent.property)) {
+									nameSpace.push(currPath.parent.property.name);
+								}
+
+								currPath = currPath.parentPath;
+								continue;
+							}
+						}
+
+						setSpecifier(id, nameSpace);
+						break;
+					} while (currPath);
+				});
+			} else if (!tplCallee.has(callee) && isStylePath(path.get('callee'))) {
+				path.get('arguments').forEach((arg) => {
+					addObjectJob(arg.isFunction() ? arg.get('body') : arg);
+				});
+			}
+		},
+		TaggedTemplateExpression: (path) => {
+			if (isStylePath(path.get('tag'))) {
+				tplLiteral.add(path.node.quasi);
+
+				if (path.node.tag.callee) {
+					tplCallee.add(path.node.tag.callee);
+				}
+			}
+		},
+	};
+
+	traverse(ast, visitor);
+	jobs.forEach((job) => job());
+
+	const objLiteralStyles = Array.from(objLiteral).map((endNode) => {
+		const objectSyntax = require('./object-syntax');
+		let startNode = endNode;
+
+		if (startNode.leadingComments && startNode.leadingComments.length) {
+			startNode = startNode.leadingComments[0];
+		}
+
+		let startIndex = startNode.start;
+		const before = source.slice(startNode.start - startNode.loc.start.column, startNode.start);
+
+		if (/^\s+$/.test(before)) {
+			startIndex -= before.length;
+		}
+
+		return {
+			startIndex,
+			endIndex: endNode.end,
+			skipConvert: true,
+			content: source,
+			opts: {
+				node: endNode,
+			},
+			syntax: objectSyntax,
+			lang: 'object-literal',
+		};
+	});
+
+	const tplLiteralStyles = [];
+
+	Array.from(tplLiteral).forEach((node) => {
+		if (
+			objLiteralStyles.some((style) => style.startIndex <= node.end && node.start < style.endIndex)
+		) {
+			return;
+		}
+
+		const quasis = node.quasis.map((node) => ({
+			start: node.start,
+			end: node.end,
+		}));
+		const style = {
+			startIndex: quasis[0].start,
+			endIndex: quasis[quasis.length - 1].end,
+			content: getTemplate(node, source),
+		};
+
+		if (node.expressions.length) {
+			const expressions = node.expressions.map((node) => ({
+				start: node.start,
+				end: node.end,
+			}));
+
+			style.syntax = loadSyntax(opts, __dirname);
+			style.lang = 'template-literal';
+			style.opts = {
+				quasis,
+				expressions,
+			};
+		} else {
+			style.lang = 'css';
+		}
+
+		let parent = null;
+		let targetStyles = tplLiteralStyles;
+
+		while (targetStyles) {
+			const target = targetStyles.find(
+				(targetStyle) =>
+					targetStyle.opts &&
+					targetStyle.opts.expressions.some(
+						(expr) => expr.start <= style.startIndex && style.endIndex < expr.end,
+					),
+			);
+
+			if (target) {
+				parent = target;
+				targetStyles = target.opts.templateLiteralStyles;
+			} else {
+				break;
+			}
+		}
+
+		if (parent) {
+			const templateLiteralStyles =
+				parent.opts.templateLiteralStyles || (parent.opts.templateLiteralStyles = []);
+
+			templateLiteralStyles.push(style);
+		} else {
+			tplLiteralStyles.push(style);
+		}
+	});
+
+	return (styles || []).concat(objLiteralStyles).concat(tplLiteralStyles);
+}
+
+module.exports = literalParser;

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

@@ -0,0 +1,7 @@
+'use strict';
+
+function getTemplate(node, source) {
+	return source.slice(node.quasis[0].start, node.quasis[node.quasis.length - 1].end);
+}
+
+module.exports = getTemplate;

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

@@ -0,0 +1,6 @@
+'use strict';
+
+const extract = require('./extract');
+const syntax = require('postcss-syntax/syntax')(extract, 'jsx');
+
+module.exports = syntax;