diff --git a/package-lock.json b/package-lock.json index 9f2851ff51..85490d8e37 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10458,7 +10458,9 @@ "dependencies": { "@csstools/css-parser-algorithms": "^4.0.2", "@csstools/css-tokenizer": "^4.0.2", - "@csstools/postcss-private-rule": "^1.0.3" + "@csstools/custom-function-parser": "^1.0.0", + "@csstools/generate-idents": "^0.0.0", + "@csstools/utilities-for-private-properties": "^0.0.0" }, "devDependencies": { "@csstools/postcss-tape": "*", diff --git a/packages/custom-function-parser/CHANGELOG.md b/packages/custom-function-parser/CHANGELOG.md index 8b75a1779d..2c322b6e0f 100644 --- a/packages/custom-function-parser/CHANGELOG.md +++ b/packages/custom-function-parser/CHANGELOG.md @@ -2,19 +2,16 @@ ### Unreleased (major) +- Omitted types are `*` for `getParameterType()` and `getReturnType()` (breaking). - Rename `CustomFunction.function` to `CustomFunction.functionNode` (breaking). - Replace `FunctionParameter.argumentType`/`getArgumentType()` with `parameterType`/`getParameterType()` (breaking). -- Omitted types are `*` for `getParameterType()` and `getReturnType()` (breaking). -- `getDefaultValue()` returns `null` when a parameter has no default (breaking). -- Add `FunctionParameter.tokens()` and `FunctionParameter.toString()`. -- Export `parseFunctionParameters()` and `parseDashedFunctionArguments()`. -- Enforce `` restrictions in default values and arguments. -- Preserve `type(...)` wrappers in `parameterType` and `{}` wrappers in `defaultValue` tokens. -- Reject `--` as a parameter name. -- Support empty default values and trailing commas with surrounding whitespace or comments. -- Fix a `RangeError` when serializing large token lists. -- Improve parameter parsing and `getDefaultValue()` performance. +- Return `null` from `getDefaultValue()` when a parameter has no default (breaking). +- Add `FunctionParameter.tokens()`/`toString()` and export `parseFunctionParameters()`/`parseDashedFunctionArguments()`. - Document that `false` signals invalid input. +- Enforce `` restrictions and preserve `type(...)`/`{}` wrappers in tokens. +- Fix a `RangeError` and improve performance for large token lists. +- Reject `--` as a parameter name. +- Support `--foo(,)`, empty defaults and trailing commas, and only trim whitespace from arguments and defaults. ### 1.0.0 diff --git a/packages/custom-function-parser/dist/index.mjs b/packages/custom-function-parser/dist/index.mjs index 8d16e6ea41..3680b67eb1 100644 --- a/packages/custom-function-parser/dist/index.mjs +++ b/packages/custom-function-parser/dist/index.mjs @@ -1 +1 @@ -import{parseListOfComponentValues as t,isWhiteSpaceOrCommentNode as e,isFunctionNode as n,isTokenNode as r,isSimpleBlockNode as o,isWhitespaceNode as s}from"@csstools/css-parser-algorithms";import{stringify as u,isTokenComment as i,isTokenOpenCurly as a,isTokenBadString as l,isTokenBadURL as c,isTokenCloseParen as f,isTokenCloseSquare as h,isTokenCloseCurly as m,isTokenSemicolon as p,isTokenDelim as g,isTokenIdent as k,isTokenColon as F,isTokenComma as y,tokenize as v}from"@csstools/css-tokenizer";var C;function getSyntaxString(r){const o=t(r).filter(t=>!e(t));return 0===o.length?"*":1===o.length&&n(o[0])&&"type"===o[0].getName().toLowerCase()?u(o[0].value.flatMap(t=>t.tokens()).filter(t=>!i(t))).trim():u(r.filter(t=>!i(t))).trim()}!function(t){t.CustomFunction="custom-function",t.FunctionParameter="function-parameter"}(C||(C={}));class CustomFunction{type=C.CustomFunction;functionNode;parameters;returnsKeyword;returnType;before;after;constructor(t,e,n,r,o=[],s=[]){this.functionNode=t,this.parameters=e,this.returnsKeyword=n,this.returnType=r,this.before=o,this.after=s}getName(){return this.functionNode.getName()}getReturnType(){return getSyntaxString(this.returnType)}tokens(){return[...this.before,...this.functionNode.tokens(),...this.returnsKeyword,...this.returnType,...this.after]}toString(){return u(this.tokens())}toJSON(){return{type:this.type,name:this.getName(),string:this.toString(),tokens:this.tokens(),parameters:this.parameters.map(t=>t.toJSON()),returnsKeyword:this.returnsKeyword,returnType:this.returnType,before:this.before,after:this.after}}isCustomFunction(){return CustomFunction.isCustomFunction(this)}static isCustomFunction(t){return!!t&&(t instanceof CustomFunction&&t.type===C.CustomFunction)}}function tokensOf(t,e=0,n=t.length){const o=[];for(let s=e;so(t)&&a(t.startToken))}class FunctionParameter{type=C.FunctionParameter;name;parameterType;colon;defaultValue;before;after;defaultValueCache=null;constructor(t,e,n,r,o=[],s=[]){this.name=t,this.parameterType=e,this.colon=n,this.defaultValue=r,this.before=o,this.after=s}getName(){return this.name[4].value}getNameToken(){return this.name}getParameterType(){return getSyntaxString(this.parameterType)}getDefaultValue(){const e=this.defaultValueCache;if(e&&e.colon===this.colon&&e.tokens===this.defaultValue)return e.value;let n=null;if(this.colon){const e=t(this.defaultValue),r=singleCurlyBlock(e),o=r?r.value:e;n=u(tokensOf(o)).trim()}return this.defaultValueCache={colon:this.colon,tokens:this.defaultValue,value:n},n}tokens(){return[...this.before,this.name,...this.parameterType,...this.colon?[this.colon]:[],...this.defaultValue,...this.after]}toString(){return u(this.tokens())}toJSON(){return{type:this.type,name:this.getName(),string:this.toString(),tokens:this.tokens(),parameterType:this.parameterType,colon:this.colon,defaultValue:this.defaultValue,before:this.before,after:this.after}}isFunctionParameter(){return FunctionParameter.isFunctionParameter(this)}static isFunctionParameter(t){return!!t&&(t instanceof FunctionParameter&&t.type===C.FunctionParameter)}}function parseFunctionParameters(t){const n=[],o=new Set;let u=0;for(;u=t.length)return n;const a=t[u];if(!r(a)||!k(a.value))return!1;const l=a.value;if(!l[4].value.startsWith("--")||"--"===l[4].value)return!1;const c=u;let f=u;u++;const h=u;let m=null;for(;u{r=!0,n?.onParseError?.(t)}});return!r&&parseCustomFunction(o)}function parse(t,e){return parseFromTokens(v({css:t},{onParseError:e?.onParseError}),e)}function parseDashedFunctionArguments(t){const n=[];let o=0,s=!1;for(let u=0;u<=t.length;u++){if(u!e(t));return 0===o.length?"*":1===o.length&&n(o[0])&&"type"===o[0].getName().toLowerCase()?i(o[0].value.flatMap(t=>t.tokens()).filter(t=>!u(t))).trim():i(r.filter(t=>!u(t))).trim()}!function(t){t.CustomFunction="custom-function",t.FunctionParameter="function-parameter"}(d||(d={}));class CustomFunction{type=d.CustomFunction;functionNode;parameters;returnsKeyword;returnType;before;after;constructor(t,e,n,r,o=[],s=[]){this.functionNode=t,this.parameters=e,this.returnsKeyword=n,this.returnType=r,this.before=o,this.after=s}getName(){return this.functionNode.getName()}getReturnType(){return getSyntaxString(this.returnType)}tokens(){return[...this.before,...this.functionNode.tokens(),...this.returnsKeyword,...this.returnType,...this.after]}toString(){return i(this.tokens())}toJSON(){return{type:this.type,name:this.getName(),string:this.toString(),tokens:this.tokens(),parameters:this.parameters.map(t=>t.toJSON()),returnsKeyword:this.returnsKeyword,returnType:this.returnType,before:this.before,after:this.after}}isCustomFunction(){return CustomFunction.isCustomFunction(this)}static isCustomFunction(t){return!!t&&(t instanceof CustomFunction&&t.type===d.CustomFunction)}}function tokensOf(t,e=0,n=t.length){const o=[];for(let s=e;so(t)&&a(t.startToken))}class FunctionParameter{type=d.FunctionParameter;name;parameterType;colon;defaultValue;before;after;defaultValueCache=null;constructor(t,e,n,r,o=[],s=[]){this.name=t,this.parameterType=e,this.colon=n,this.defaultValue=r,this.before=o,this.after=s}getName(){return this.name[4].value}getNameToken(){return this.name}getParameterType(){return getSyntaxString(this.parameterType)}getDefaultValue(){const e=this.defaultValueCache;if(e&&e.colon===this.colon&&e.tokens===this.defaultValue)return e.value;let n=null;if(this.colon){const e=t(this.defaultValue),r=singleCurlyBlock(e);n=i(trimWhitespace(tokensOf(r?r.value:e)))}return this.defaultValueCache={colon:this.colon,tokens:this.defaultValue,value:n},n}tokens(){return[...this.before,this.name,...this.parameterType,...this.colon?[this.colon]:[],...this.defaultValue,...this.after]}toString(){return i(this.tokens())}toJSON(){return{type:this.type,name:this.getName(),string:this.toString(),tokens:this.tokens(),parameterType:this.parameterType,colon:this.colon,defaultValue:this.defaultValue,before:this.before,after:this.after}}isFunctionParameter(){return FunctionParameter.isFunctionParameter(this)}static isFunctionParameter(t){return!!t&&(t instanceof FunctionParameter&&t.type===d.FunctionParameter)}}function trimWhitespace(t){let e=0,n=t.length;for(;ee&&y(t[n-1]);)n--;return t.slice(e,n)}function parseFunctionParameters(t){const n=[],o=new Set;let i=0;for(;i=t.length)return n;const a=t[i];if(r(a)&&k(a.value))return!(n.length>0||!isOnlyWhiteSpaceOrComments(t,i+1))&&n;if(!r(a)||!F(a.value))return!1;const l=a.value;if(!l[4].value.startsWith("--")||"--"===l[4].value)return!1;const c=i;let f=i;i++;const h=i;let m=null;for(;i{r=!0,n?.onParseError?.(t)}});return!r&&parseCustomFunction(o)}function parse(t,e){return parseFromTokens(C({css:t},{onParseError:e?.onParseError}),e)}function parseDashedFunctionArguments(t){const n=[];let o=0,s=!1;for(let i=0;i<=t.length;i++){if(ie&&s(t[n-1]);)n--;return t.slice(e,n)}function isCustomFunction(t){return CustomFunction.isCustomFunction(t)}function isFunctionParameter(t){return FunctionParameter.isFunctionParameter(t)}export{CustomFunction,FunctionParameter,d as NodeType,isCustomFunction,isFunctionParameter,parse,parseDashedFunctionArguments,parseFromTokens,parseFunctionParameters}; diff --git a/packages/custom-function-parser/src/nodes/function-parameter.ts b/packages/custom-function-parser/src/nodes/function-parameter.ts index 78a046ee04..e6635c79a9 100644 --- a/packages/custom-function-parser/src/nodes/function-parameter.ts +++ b/packages/custom-function-parser/src/nodes/function-parameter.ts @@ -1,5 +1,5 @@ import type { CSSToken, TokenColon, TokenIdent } from '@csstools/css-tokenizer'; -import { stringify } from '@csstools/css-tokenizer'; +import { isTokenWhitespace, stringify } from '@csstools/css-tokenizer'; import { parseListOfComponentValues } from '@csstools/css-parser-algorithms'; import { NodeType } from '../util/node-type'; import { tokensOf } from '../util/component-values'; @@ -59,8 +59,7 @@ export class FunctionParameter { if (this.colon) { const componentValues = parseListOfComponentValues(this.defaultValue); const block = singleCurlyBlock(componentValues); - const value = block ? block.value : componentValues; - defaultValue = stringify(tokensOf(value)).trim(); + defaultValue = stringify(trimWhitespace(tokensOf(block ? block.value : componentValues))); } this.defaultValueCache = { @@ -123,3 +122,19 @@ export class FunctionParameter { return x.type === NodeType.FunctionParameter; } } + +/** Drop leading and trailing whitespace tokens, but keep comments as written. */ +function trimWhitespace(tokens: Array): Array { + let start = 0; + let end = tokens.length; + + while (start < end && isTokenWhitespace(tokens[start])) { + start++; + } + + while (end > start && isTokenWhitespace(tokens[end - 1])) { + end--; + } + + return tokens.slice(start, end); +} diff --git a/packages/custom-function-parser/src/parser/parse-dashed-function-arguments.ts b/packages/custom-function-parser/src/parser/parse-dashed-function-arguments.ts index dde8490a3d..e8f4815624 100644 --- a/packages/custom-function-parser/src/parser/parse-dashed-function-arguments.ts +++ b/packages/custom-function-parser/src/parser/parse-dashed-function-arguments.ts @@ -1,5 +1,5 @@ import type { ComponentValue } from '@csstools/css-parser-algorithms'; -import { isTokenNode, isWhiteSpaceOrCommentNode } from '@csstools/css-parser-algorithms'; +import { isTokenNode, isWhiteSpaceOrCommentNode, isWhitespaceNode } from '@csstools/css-parser-algorithms'; import { isTokenComma } from '@csstools/css-tokenizer'; import { containsCurlyBlock, hasInvalidDeclarationValue, singleCurlyBlock } from '../util/declaration-value'; @@ -60,21 +60,16 @@ function unwrapArgument(list: Array): Array | fa function trim(componentValues: Array): Array { let start = 0; - let end = 0; - let sawMeaningful = false; + let end = componentValues.length; - for (let i = 0; i < componentValues.length; i++) { - if (isWhiteSpaceOrCommentNode(componentValues[i])) { - continue; - } - - if (!sawMeaningful) { - start = i; - sawMeaningful = true; - } + // Only whitespace is trimmed. Comments are preserved as written. + while (start < end && isWhitespaceNode(componentValues[start])) { + start++; + } - end = i + 1; + while (end > start && isWhitespaceNode(componentValues[end - 1])) { + end--; } - return sawMeaningful ? componentValues.slice(start, end) : []; + return componentValues.slice(start, end); } diff --git a/packages/custom-function-parser/src/parser/parse-function-parameters.ts b/packages/custom-function-parser/src/parser/parse-function-parameters.ts index 5bc8762675..cef6a19e97 100644 --- a/packages/custom-function-parser/src/parser/parse-function-parameters.ts +++ b/packages/custom-function-parser/src/parser/parse-function-parameters.ts @@ -31,6 +31,17 @@ export function parseFunctionParameters(componentValues: Array): } const nameComponentValue = componentValues[i]; + + // A single trailing comma can follow an empty parameter list: + // `@mixin --foo(,)` is the same as `@mixin --foo()`. + if (isTokenNode(nameComponentValue) && isTokenComma(nameComponentValue.value)) { + if (parameters.length > 0 || !isOnlyWhiteSpaceOrComments(componentValues, i + 1)) { + return false; + } + + return parameters; + } + if (!isTokenNode(nameComponentValue) || !isTokenIdent(nameComponentValue.value)) { return false; } @@ -146,3 +157,14 @@ export function parseFunctionParameters(componentValues: Array): return parameters; } + +/** Whether every component value from `start` on is whitespace or a comment. */ +function isOnlyWhiteSpaceOrComments(componentValues: Array, start: number): boolean { + for (let i = start; i < componentValues.length; i++) { + if (!isWhiteSpaceOrCommentNode(componentValues[i])) { + return false; + } + } + + return true; +} diff --git a/packages/custom-function-parser/test/parse-arguments/0002.mjs b/packages/custom-function-parser/test/parse-arguments/0002.mjs index b44096aaff..3846d4e538 100644 --- a/packages/custom-function-parser/test/parse-arguments/0002.mjs +++ b/packages/custom-function-parser/test/parse-arguments/0002.mjs @@ -66,4 +66,14 @@ test('parseDashedFunctionArguments empty arguments', async (t) => { assert.deepEqual(stringified('--a(1, )'), ['1']); assert.deepEqual(stringified('--a(1, /* a comment */)'), ['1']); }); + + await t.test('trims whitespace but keeps comments', () => { + assert.deepEqual(stringified('--a( 1px )'), ['1px']); + assert.deepEqual(stringified('--a(/* a comment */ 1px)'), ['/* a comment */ 1px']); + assert.deepEqual(stringified('--a(1px /* a comment */)'), ['1px /* a comment */']); + }); + + await t.test('trims only whitespace', () => { + assert.deepEqual(stringified('--a(\u00A0red)'), ['\u00A0red']); + }); }); diff --git a/packages/custom-function-parser/test/parse-parameters/0001.mjs b/packages/custom-function-parser/test/parse-parameters/0001.mjs index 48bb83f022..fc9e952216 100644 --- a/packages/custom-function-parser/test/parse-parameters/0001.mjs +++ b/packages/custom-function-parser/test/parse-parameters/0001.mjs @@ -36,10 +36,23 @@ test('parseFunctionParameters', async (t) => { assert.deepEqual(parameters.map((parameter) => parameter.getName()), ['--a', '--b']); }); + await t.test('allows a lone trailing comma', () => { + assert.deepEqual(parseParameters(','), []); + assert.deepEqual(parseParameters(' , '), []); + assert.deepEqual(parseParameters('/* a comment */,'), []); + }); + + await t.test('trims only whitespace from defaults', () => { + assert.equal(parseParameters('--a: 1px').at(0).getDefaultValue(), '1px'); + assert.equal(parseParameters('--a: \u00A0red').at(0).getDefaultValue(), '\u00A0red'); + }); + await t.test('rejects invalid parameter lists', () => { assert.equal(parseParameters('--'), false); assert.equal(parseParameters('--a: red !important'), false); assert.equal(parseParameters('--a: red;'), false); assert.equal(parseParameters('--a, --a'), false); + assert.equal(parseParameters(',--a'), false); + assert.equal(parseParameters('--a,,'), false); }); }); diff --git a/packages/custom-function-parser/test/parse-prelude/0001.mjs b/packages/custom-function-parser/test/parse-prelude/0001.mjs index 4539a51c09..bd78993dc0 100644 --- a/packages/custom-function-parser/test/parse-prelude/0001.mjs +++ b/packages/custom-function-parser/test/parse-prelude/0001.mjs @@ -70,6 +70,8 @@ const valid = [ '--foo(--x) returns type()', '--foo(--x) returns type( | auto)', '--foo(--x) returns type(foo | bar)', + '--foo(,)', + '--foo( , )', ]; const invalid = [ @@ -86,7 +88,6 @@ const invalid = [ '--foo(--x: {1px} {2px})', '--foo(--x: var(--y, 10px)', '--foo(!)', - '--foo(,)', '--foo(,,,)', '--foo(--x, ;)', '--foo(;)', diff --git a/packages/utilities-for-private-properties/README.md b/packages/utilities-for-private-properties/README.md index 5f2a8a4a03..763057663c 100644 --- a/packages/utilities-for-private-properties/README.md +++ b/packages/utilities-for-private-properties/README.md @@ -27,7 +27,21 @@ const registrations = transpiler.transpile(root.nodes); root.append(...registrations); ``` -`@property` rules are only hoisted out of `@layer`, `@media` and `@supports` group rules. Registrations inside `@container`, `@scope` or `@starting-style` are left untouched, because those conditions cannot be preserved at the top level. +Nodes that are substituted into a style rule but are not its children, for example the contents of +an `@contents` block, can be transpiled in the scope of that style rule: + +```ts +transpiler.transpile(nodes, { scope: styleRule }); +``` + +With `preserve: true` the `@private` rules are kept and references inside `@apply` and `@contents` +blocks are left alone. Transpiled declarations are still hoisted, so the original notation keeps +working where `@private` is supported. + +`@property` rules are hoisted out of `@layer`, `@media` and `@supports` group rules, and the +`@layer`, `@media` and `@supports` conditions are kept. `@container`, `@scope` and +`@starting-style` do not constrain name-defining at-rules, so registrations inside them are hoisted +without those conditions. [cli-url]: https://github.com/csstools/postcss-plugins/actions/workflows/test.yml?query=workflow/test [discord]: https://discord.gg/bUadyRwkJS diff --git a/packages/utilities-for-private-properties/dist/index.d.ts b/packages/utilities-for-private-properties/dist/index.d.ts index 1b04b82b0d..f2e22ca86c 100644 --- a/packages/utilities-for-private-properties/dist/index.d.ts +++ b/packages/utilities-for-private-properties/dist/index.d.ts @@ -1,5 +1,6 @@ import type { AtRule } from 'postcss'; import type { ChildNode } from 'postcss'; +import type { Rule } from 'postcss'; /** * Create a transpiler for private custom properties. @@ -10,6 +11,17 @@ import type { ChildNode } from 'postcss'; */ export declare function createPrivatePropertyTranspiler(options?: PrivatePropertyTranspilerOptions): PrivatePropertyTranspiler; +export declare type PrivatePropertyTranspileOptions = { + /** + * Style rule that owns the private property names of `nodes`. + * + * Use this when `nodes` are substituted into a style rule but are not its + * direct children, for example a `@contents` block that is authored at an + * `@apply` site and placed inside a mixin body. + */ + scope?: Rule; +}; + export declare type PrivatePropertyTranspiler = { /** * Transpile private rules and private property references in `nodes`. @@ -17,7 +29,7 @@ export declare type PrivatePropertyTranspiler = { * Mutates `nodes` in place and returns the `@property` rules that must be * appended to the root of the tree. */ - transpile: (nodes: Array) => Array; + transpile: (nodes: Array, options?: PrivatePropertyTranspileOptions) => Array; }; export declare type PrivatePropertyTranspilerOptions = { @@ -33,6 +45,14 @@ export declare type PrivatePropertyTranspilerOptions = { * private properties. */ allowUntranspiledMixins?: boolean; + /** + * Keep `@private` rules and leave references inside `@apply` and `@contents` + * blocks alone. + * + * Transpiled declarations are still hoisted, so the original notation keeps + * working where `@private` is supported. + */ + preserve?: boolean; }; export { } diff --git a/packages/utilities-for-private-properties/dist/index.mjs b/packages/utilities-for-private-properties/dist/index.mjs index 05bb553c18..c7a02d274d 100644 --- a/packages/utilities-for-private-properties/dist/index.mjs +++ b/packages/utilities-for-private-properties/dist/index.mjs @@ -1 +1 @@ -import{tokenize as e,isTokenIdent as t,mutateIdent as r,isTokenColon as n,isTokenDelim as s}from"@csstools/css-tokenizer";import{parseListOfComponentValues as i,walk as a,isTokenNode as o,stringify as l,isFunctionNode as p,isWhiteSpaceOrCommentNode as u,isSimpleBlockNode as c}from"@csstools/css-parser-algorithms";import{generateUniqueDashedIdent as f,hashFileBasenameAndDir as m}from"@csstools/generate-idents";import{collectPropertyRegistrations as y,registeredCustomPropertyNames as h,rewriteCustomPropertyNames as v,wrapInConditionalGroupRules as d}from"@csstools/utilities-for-property-registrations";const P=/\b(var|if|style|inherit)\(/i,R=/^apply$/i,N=/^container$/i,g=/^contents$/i,S=/^function$/i,$=/^inherit$/i,k=/^keyframes$/i,w=/^layer$/i,x=/^media$/i,C=/^mixin$/i,D=/^(container|layer|media|scope|starting-style|supports)$/i,A=/^private$/i,M=/^(transition|transition-property)$/i,F=/^property$/i,W=/^style$/i,U=/^supports$/i,G=/^var$/i;class Transpiler{privatePropertyNames=new WeakMap;skippedStyleRules=new WeakSet;counter=0;namespace;allowUntranspiledMixins;propertyRegistrations=[];constructor(e){this.namespace=e?.namespace||"p",this.allowUntranspiledMixins=!0===e?.allowUntranspiledMixins}transpile(e){this.collectSkippedStyleRules(e);for(const t of e)"atrule"===t.type&&A.test(t.name)&&this.transpilePrivateRule(t),isContainer(t)&&t.walkAtRules(A,e=>this.transpilePrivateRule(e));for(const t of e)"decl"!==t.type?isContainer(t)&&t.walkDecls(e=>this.transpileDeclaration(e)):this.transpileDeclaration(t);for(const t of e)"atrule"!==t.type?isContainer(t)&&t.walkAtRules(e=>this.transpileContainerRule(e)):this.transpileContainerRule(t);const t=this.propertyRegistrations;return this.propertyRegistrations=[],t}transpilePrivateRule(e){const t=findStyleRule(e);if(!t||this.isSkipped(e))return;const r=this.privatePropertyNamesForRule(t);this.hoistPrivatePropertyRegistrations(e,r),this.cleanPrivateRule(e,r),e.nodes?.length?(e.before(e.nodes.map(e=>e.clone())),this.removePrivateRule(e,t)):this.removePrivateRule(e,t)}collectSkippedStyleRules(e){const t=[];for(const r of e)"rule"===r.type&&t.push(r),isContainer(r)&&r.walkRules(e=>{t.push(e)});for(const e of t){if(isInsideMixinOrFunction(e)){this.skipStyleRule(e);continue}if(!this.allowUntranspiledMixins&&hasUntranspiledMixin(e)){this.skipStyleRule(e);continue}let t=!1;e.walkAtRules(A,r=>{if(t)return;if(findStyleRule(r)!==e)return;const n=y(r,{isConditionalGroupRule:()=>!1,shouldDescendInto:canContainPrivateContents});for(const{propertyRule:e}of n)if(h(e).length&®istrationWrappers(e).hasAnonymousLayer)return void(t=!0)}),t&&this.skipStyleRule(e)}}skipStyleRule(e){this.skippedStyleRules.add(e);for(const t of styleRuleAncestors(e))this.skippedStyleRules.add(t)}isSkipped(e){for(const t of styleRuleAncestors(e))if(this.skippedStyleRules.has(t))return!0;return!1}hoistPrivatePropertyRegistrations(e,t){const r=y(e,{isConditionalGroupRule:()=>!1,shouldDescendInto:canContainPrivateContents});for(const{propertyRule:e}of r){const r=e.clone(),n=v(r,e=>`${t.prefix}${e}`);if(!n)continue;const{wrappers:s}=registrationWrappers(e);e.remove();for(const e of n)t.names.add(e);this.propertyRegistrations.push(...d([r],s))}}privatePropertyNamesForRule(e){const t=this.privatePropertyNames.get(e);if(t)return t;const r={prefix:f(this.namespace,m(e.source?.input.from),this.counter.toString(36)),names:new Set};return this.counter++,this.privatePropertyNames.set(e,r),r}prefixForPropertyName(e,t){if(this.isSkipped(e))return!1;for(const r of styleRuleAncestors(e)){const e=this.privatePropertyNames.get(r);if(e?.names.has(t))return e.prefix}return!1}hasPrivatePropertyNames(e){if(this.isSkipped(e))return!1;for(const t of styleRuleAncestors(e))if(this.privatePropertyNames.get(t)?.names.size)return!0;return!1}cleanPrivateRule(e,t){this.cleanPrivateRuleNodes(e,t),removeEmptyNestedGroupRules(e)}cleanPrivateRuleNodes(e,t){const r=e.nodes||[];for(let e=r.length-1;e>=0;e--){const n=r[e];if("decl"===n.type){const e=unescapedPropertyName(n.prop);if(null===e){n.remove();continue}t.names.add(e),n.prop=`${t.prefix}${n.prop}`;continue}"atrule"===n.type&&F.test(n.name)||("atrule"===n.type&&D.test(n.name)&&n.nodes?this.cleanPrivateRuleNodes(n,t):n.remove())}}removePrivateRule(e,t){let r=e.parent;for(e.remove();r&&r!==t;){const e=r.parent;if("atrule"===r.type){const e=r;!D.test(e.name)||w.test(e.name)||e.nodes?.length||e.remove()}r=e}}transpileDeclaration(e){this.transpileDeclarationPropertyName(e),M.test(e.prop)&&this.transpilePropertyListValue(e),this.transpileDeclarationValue(e)}transpilePropertyListValue(n){if(!n.value.includes("--"))return;if(!this.hasPrivatePropertyNames(n))return;const s=i(e({css:n.value}));let p=!1;a(s,e=>{if(!o(e.node)||!t(e.node.value))return;const s=e.node.value[4].value;if(!s.startsWith("--"))return;const i=this.prefixForPropertyName(n,s);i&&(r(e.node.value,`${i}${s}`),p=!0)}),p&&(n.value=l([s]))}transpileDeclarationPropertyName(e){if(!e.variable)return;const t=unescapedPropertyName(e.prop);if(null===t)return;const r=this.prefixForPropertyName(e,t);r&&(e.prop=`${r}${e.prop}`)}transpileDeclarationValue(t){if(!P.test(t.value))return;if(!this.hasPrivatePropertyNames(t))return;const r=i(e({css:t.value}));this.rewritePrivateReferences(r,t)&&(t.value=l([r]))}transpileContainerRule(t){if(!N.test(t.name))return;if(!t.params.includes("--"))return;if(!this.hasPrivatePropertyNames(t))return;const r=i(e({css:t.params}));this.rewritePrivateReferences(r,t)&&(t.params=l([r]))}rewritePrivateReferences(e,t){let r=!1;return a(e,e=>{if(!p(e.node))return;const n=e.node.getName();W.test(n)?r=this.rewriteStyleQuery(e.node.value,t)||r:(G.test(n)||$.test(n))&&(r=this.rewritePrivatePropertyName(e.node,t)||r)}),r}rewriteStyleQuery(e,r){let i=!1,a=-1,l=-1;const p=[];for(let t=0;t"===e||"="===e}function canContainPrivateContents(e){return!!e.nodes&&D.test(e.name)}function hasUntranspiledMixin(e){let t=!1;return e.walkAtRules(e=>{(R.test(e.name)||g.test(e.name))&&(t=!0)}),t}function isInsideMixinOrFunction(e){let t=e.parent;for(;t;){if("atrule"===t.type&&(C.test(t.name)||S.test(t.name)))return!0;t=t.parent}return!1}function registrationWrappers(e){const t=[];let r=!1,n=e.parent;for(;n;){if("atrule"===n.type){const e=n;w.test(e.name)?e.params.trim()?t.unshift(e):r=!0:(x.test(e.name)||U.test(e.name))&&t.unshift(e)}n=n.parent}return{wrappers:t,hasAnonymousLayer:r}}function removeEmptyNestedGroupRules(e){const t=e.nodes||[];for(let e=t.length-1;e>=0;e--){const r=t[e];"atrule"===r.type&&D.test(r.name)&&(removeEmptyNestedGroupRules(r),w.test(r.name)||r.nodes?.length||r.remove())}}function unescapedPropertyName(r){const n=e({css:r})[0];if(!n||!t(n))return null;const s=n[4].value;return"--"!==s&&s.startsWith("--")?s:null}function isContainer(e){return"rule"===e.type||"atrule"===e.type}function findStyleRule(e,t=!1){if(!e.parent)return!1;if("rule"===e.parent.type){const t=e.parent;return("atrule"!==t.parent?.type||!k.test(t.parent.name))&&t}if("atrule"===e.parent.type){const r=e.parent;if(D.test(r.name)||t&&(R.test(r.name)||g.test(r.name)))return findStyleRule(r,t)}return!1}function styleRuleAncestors(e){const t=[];let r=e;for(;;){const e=findStyleRule(r,!0);if(!e)break;t.push(e),r=e}return t}function createPrivatePropertyTranspiler(e){const t=new Transpiler(e);return{transpile:e=>t.transpile(e)}}export{createPrivatePropertyTranspiler}; +import{tokenize as e,isTokenIdent as t,mutateIdent as r,isTokenColon as s,isTokenDelim as n}from"@csstools/css-tokenizer";import{parseListOfComponentValues as i,walk as o,isTokenNode as a,stringify as l,isFunctionNode as p,isWhiteSpaceOrCommentNode as u,isSimpleBlockNode as c}from"@csstools/css-parser-algorithms";import{generateUniqueDashedIdent as f,hashFileBasenameAndDir as h}from"@csstools/generate-idents";import{collectPropertyRegistrations as m,registeredCustomPropertyNames as y,rewriteCustomPropertyNames as v,wrapInConditionalGroupRules as d}from"@csstools/utilities-for-property-registrations";const R=/\b(var|if|style|inherit)\(/i,P=/^apply$/i,N=/^container$/i,w=/^contents$/i,S=/^function$/i,k=/^inherit$/i,g=/^keyframes$/i,$=/^layer$/i,C=/^media$/i,x=/^mixin$/i,D=/^(container|layer|media|scope|starting-style|supports)$/i,F=/^private$/i,A=/^(transition|transition-property)$/i,M=/^property$/i,W=/^style$/i,b=/^supports$/i,G=/^var$/i;class Transpiler{privatePropertyNames=new WeakMap;processedPrivateRules=new WeakSet;skippedStyleRules=new WeakSet;counter=0;namespace;allowUntranspiledMixins;preserve;propertyRegistrations=[];scope;scopeRules=new Set;constructor(e){this.namespace=e?.namespace||"p",this.allowUntranspiledMixins=!0===e?.allowUntranspiledMixins,this.preserve=!0===e?.preserve}transpile(e,t){const r=this.scope,s=this.scopeRules;this.scope=t?.scope,this.scopeRules=collectRules(e);try{this.collectSkippedStyleRules(e);const t=[];for(const r of e)"atrule"===r.type&&F.test(r.name)&&t.push(...this.transpilePrivateRule(r)),isContainer(r)&&r.walkAtRules(F,e=>{t.push(...this.transpilePrivateRule(e))});for(const t of e)"decl"!==t.type?isContainer(t)&&t.walkDecls(e=>this.transpileDeclaration(e)):this.transpileDeclaration(t);for(const e of t)this.transpileDeclaration(e);for(const t of e)"atrule"!==t.type?isContainer(t)&&t.walkAtRules(e=>this.transpileContainerRule(e)):this.transpileContainerRule(t);const r=this.propertyRegistrations;return this.propertyRegistrations=[],r}finally{this.scope=r,this.scopeRules=s}}transpilePrivateRule(e){const t=this.ownerFor(e);if(!t||this.isSkipped(e)||this.processedPrivateRules.has(e))return[];this.processedPrivateRules.add(e);const r=this.privatePropertyNamesForRule(t);if(this.hoistPrivatePropertyRegistrations(e,r),this.preserve){const t=e.clone();this.cleanPrivateRule(t,r),t.walkAtRules(M,e=>{e.remove()}),removeEmptyNestedGroupRules(t);const s=(t.nodes||[]).map(e=>e.clone());return s.length&&e.before(s),s.filter(e=>"decl"===e.type)}if(this.cleanPrivateRule(e,r),!e.nodes?.length)return this.removePrivateRule(e,t),[];const s=e.nodes.map(e=>e.clone());return e.before(s),this.removePrivateRule(e,t),s.filter(e=>"decl"===e.type)}collectSkippedStyleRules(e){const t=[];for(const r of e)"rule"===r.type&&t.push(r),isContainer(r)&&r.walkRules(e=>{t.push(e)});for(const e of t){if(isInsideMixinOrFunction(e)){this.skipStyleRule(e);continue}if(!this.allowUntranspiledMixins&&hasUntranspiledMixin(e)){this.skipStyleRule(e);continue}let t=!1;e.walkAtRules(F,r=>{if(t)return;if(findStyleRule(r)!==e)return;const s=m(r,{isConditionalGroupRule:()=>!1,shouldDescendInto:canContainPrivateContents});for(const{propertyRule:e}of s)if(y(e).length&®istrationWrappers(e).hasAnonymousLayer)return void(t=!0)}),t&&this.skipStyleRule(e)}}skipStyleRule(e){this.skippedStyleRules.add(e);for(const t of styleRuleAncestors(e))this.skippedStyleRules.add(t)}ownerFor(e){const t=findStyleRule(e);return this.scope?t&&this.scopeRules.has(t)?t:this.scope:t}styleRuleChain(e){const t=[];let r=e,s=!1;for(;;){const e=findStyleRule(r,!this.preserve);if(!e)break;!this.scope||s||this.scopeRules.has(e)?(t.push(e),r=e):(s=!0,t.push(this.scope),r=this.scope)}return t}isSkipped(e){for(const t of this.styleRuleChain(e))if(this.skippedStyleRules.has(t))return!0;return!1}hoistPrivatePropertyRegistrations(e,t){const r=m(e,{isConditionalGroupRule:()=>!1,shouldDescendInto:canContainPrivateContents});for(const{propertyRule:e}of r){const r=e.clone(),s=v(r,e=>`${t.prefix}${e}`);if(!s)continue;const{wrappers:n}=registrationWrappers(e);this.preserve||e.remove();for(const e of s)t.names.add(e);this.propertyRegistrations.push(...d([r],n))}}privatePropertyNamesForRule(e){const t=this.privatePropertyNames.get(e);if(t)return t;const r={prefix:f(this.namespace,h(e.source?.input.from),this.counter.toString(36)),names:new Set};return this.counter++,this.privatePropertyNames.set(e,r),r}prefixForPropertyName(e,t){if(this.isSkipped(e))return!1;for(const r of this.styleRuleChain(e)){const e=this.privatePropertyNames.get(r);if(e?.names.has(t))return e.prefix}return!1}hasPrivatePropertyNames(e){if(this.isSkipped(e))return!1;for(const t of this.styleRuleChain(e))if(this.privatePropertyNames.get(t)?.names.size)return!0;return!1}cleanPrivateRule(e,t){this.cleanPrivateRuleNodes(e,t),removeEmptyNestedGroupRules(e)}cleanPrivateRuleNodes(e,t){const r=e.nodes||[];for(let e=r.length-1;e>=0;e--){const s=r[e];if("decl"===s.type){const e=unescapedPropertyName(s.prop);if(null===e){s.remove();continue}t.names.add(e),s.prop=`${t.prefix}${s.prop}`;continue}"atrule"===s.type&&M.test(s.name)||("atrule"===s.type&&D.test(s.name)&&s.nodes?this.cleanPrivateRuleNodes(s,t):s.remove())}}removePrivateRule(e,t){let r=e.parent;for(e.remove();r&&r!==t;){const e=r.parent;if("atrule"===r.type){const e=r;!D.test(e.name)||$.test(e.name)||e.nodes?.length||e.remove()}r=e}}transpileDeclaration(e){this.transpileDeclarationPropertyName(e),A.test(e.prop)&&this.transpilePropertyListValue(e),this.transpileDeclarationValue(e)}transpilePropertyListValue(s){if(!s.value.includes("--"))return;if(!this.hasPrivatePropertyNames(s))return;const n=i(e({css:s.value}));let p=!1;o(n,e=>{if(!a(e.node)||!t(e.node.value))return;const n=e.node.value[4].value;if(!n.startsWith("--"))return;const i=this.prefixForPropertyName(s,n);i&&(r(e.node.value,`${i}${n}`),p=!0)}),p&&(s.value=l([n]))}transpileDeclarationPropertyName(e){if(!e.variable)return;const t=unescapedPropertyName(e.prop);if(null===t)return;const r=this.prefixForPropertyName(e,t);r&&(e.prop=`${r}${e.prop}`)}transpileDeclarationValue(t){if(!R.test(t.value))return;if(!this.hasPrivatePropertyNames(t))return;const r=i(e({css:t.value}));this.rewritePrivateReferences(r,t)&&(t.value=l([r]))}transpileContainerRule(t){if(!N.test(t.name))return;if(!t.params.includes("--"))return;if(!this.hasPrivatePropertyNames(t))return;const r=i(e({css:t.params}));this.rewritePrivateReferences(r,t)&&(t.params=l([r]))}rewritePrivateReferences(e,t){let r=!1;return o(e,e=>{if(!p(e.node))return;const s=e.node.getName();W.test(s)?r=this.rewriteStyleQuery(e.node.value,t)||r:(G.test(s)||k.test(s))&&(r=this.rewritePrivatePropertyName(e.node,t)||r)}),r}rewriteStyleQuery(e,r){let i=!1,o=-1,l=-1;const p=[];for(let t=0;t"===e||"="===e}function canContainPrivateContents(e){return!!e.nodes&&D.test(e.name)}function hasUntranspiledMixin(e){let t=!1;return e.walkAtRules(e=>{(P.test(e.name)||w.test(e.name))&&(t=!0)}),t}function isInsideMixinOrFunction(e){let t=e.parent;for(;t;){if("atrule"===t.type&&(x.test(t.name)||S.test(t.name)))return!0;t=t.parent}return!1}function registrationWrappers(e){const t=[];let r=!1,s=e.parent;for(;s;){if("atrule"===s.type){const e=s;$.test(e.name)?e.params.trim()?t.unshift(e):r=!0:(C.test(e.name)||b.test(e.name))&&t.unshift(e)}s=s.parent}return{wrappers:t,hasAnonymousLayer:r}}function removeEmptyNestedGroupRules(e){const t=e.nodes||[];for(let e=t.length-1;e>=0;e--){const r=t[e];"atrule"===r.type&&D.test(r.name)&&(removeEmptyNestedGroupRules(r),$.test(r.name)||r.nodes?.length||r.remove())}}function unescapedPropertyName(r){const s=e({css:r})[0];if(!s||!t(s))return null;const n=s[4].value;return"--"!==n&&n.startsWith("--")?n:null}function isContainer(e){return"rule"===e.type||"atrule"===e.type}function collectRules(e){const t=new Set;for(const r of e)"rule"===r.type&&t.add(r),isContainer(r)&&r.walkRules(e=>{t.add(e)});return t}function findStyleRule(e,t=!1){if(!e.parent)return!1;if("rule"===e.parent.type){const t=e.parent;return("atrule"!==t.parent?.type||!g.test(t.parent.name))&&t}if("atrule"===e.parent.type){const r=e.parent;if(D.test(r.name)||t&&(P.test(r.name)||w.test(r.name)))return findStyleRule(r,t)}return!1}function styleRuleAncestors(e){const t=[];let r=e;for(;;){const e=findStyleRule(r,!0);if(!e)break;t.push(e),r=e}return t}function createPrivatePropertyTranspiler(e){const t=new Transpiler(e);return{transpile:(e,r)=>t.transpile(e,r)}}export{createPrivatePropertyTranspiler}; diff --git a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.api.json b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.api.json index 6188f27401..d94eb5515b 100644 --- a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.api.json +++ b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.api.json @@ -234,6 +234,41 @@ ], "name": "createPrivatePropertyTranspiler" }, + { + "kind": "TypeAlias", + "canonicalReference": "@csstools/utilities-for-private-properties!PrivatePropertyTranspileOptions:type", + "docComment": "", + "excerptTokens": [ + { + "kind": "Content", + "text": "export type PrivatePropertyTranspileOptions = " + }, + { + "kind": "Content", + "text": "{\n scope?: " + }, + { + "kind": "Reference", + "text": "Rule", + "canonicalReference": "postcss!Rule_:class" + }, + { + "kind": "Content", + "text": ";\n}" + }, + { + "kind": "Content", + "text": ";" + } + ], + "fileUrlPath": "dist/_types/transpiler.d.ts", + "releaseTag": "Public", + "name": "PrivatePropertyTranspileOptions", + "typeTokenRange": { + "startIndex": 1, + "endIndex": 4 + } + }, { "kind": "TypeAlias", "canonicalReference": "@csstools/utilities-for-private-properties!PrivatePropertyTranspiler:type", @@ -263,7 +298,16 @@ }, { "kind": "Content", - "text": ">) => " + "text": ">, options?: " + }, + { + "kind": "Reference", + "text": "PrivatePropertyTranspileOptions", + "canonicalReference": "@csstools/utilities-for-private-properties!PrivatePropertyTranspileOptions:type" + }, + { + "kind": "Content", + "text": ") => " }, { "kind": "Reference", @@ -293,7 +337,7 @@ "name": "PrivatePropertyTranspiler", "typeTokenRange": { "startIndex": 1, - "endIndex": 10 + "endIndex": 12 } }, { @@ -307,7 +351,7 @@ }, { "kind": "Content", - "text": "{\n namespace?: string;\n allowUntranspiledMixins?: boolean;\n}" + "text": "{\n namespace?: string;\n allowUntranspiledMixins?: boolean;\n preserve?: boolean;\n}" }, { "kind": "Content", diff --git a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.md b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.md index 39ae9963d2..5a58b552b8 100644 --- a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.md +++ b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.md @@ -47,6 +47,15 @@ Description +[PrivatePropertyTranspileOptions](./utilities-for-private-properties.privatepropertytranspileoptions.md) + + + + + + + + [PrivatePropertyTranspiler](./utilities-for-private-properties.privatepropertytranspiler.md) diff --git a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileoptions.md b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileoptions.md new file mode 100644 index 0000000000..8dd8d32ebb --- /dev/null +++ b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileoptions.md @@ -0,0 +1,13 @@ + + +[Home](./index.md) > [@csstools/utilities-for-private-properties](./utilities-for-private-properties.md) > [PrivatePropertyTranspileOptions](./utilities-for-private-properties.privatepropertytranspileoptions.md) + +## PrivatePropertyTranspileOptions type + +**Signature:** + +```typescript +export type PrivatePropertyTranspileOptions = { + scope?: Rule; +}; +``` diff --git a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspiler.md b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspiler.md index 4ecbdf9a7b..a0334b9598 100644 --- a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspiler.md +++ b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspiler.md @@ -8,6 +8,8 @@ ```typescript export type PrivatePropertyTranspiler = { - transpile: (nodes: Array) => Array; + transpile: (nodes: Array, options?: PrivatePropertyTranspileOptions) => Array; }; ``` +**References:** [PrivatePropertyTranspileOptions](./utilities-for-private-properties.privatepropertytranspileoptions.md) + diff --git a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileroptions.md b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileroptions.md index 339ff5d0e0..18d5c81308 100644 --- a/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileroptions.md +++ b/packages/utilities-for-private-properties/docs/utilities-for-private-properties.privatepropertytranspileroptions.md @@ -10,5 +10,6 @@ export type PrivatePropertyTranspilerOptions = { namespace?: string; allowUntranspiledMixins?: boolean; + preserve?: boolean; }; ``` diff --git a/packages/utilities-for-private-properties/src/index.ts b/packages/utilities-for-private-properties/src/index.ts index 28714aaa88..4499092414 100644 --- a/packages/utilities-for-private-properties/src/index.ts +++ b/packages/utilities-for-private-properties/src/index.ts @@ -1,8 +1,8 @@ import type { AtRule, ChildNode } from 'postcss'; -import type { PrivatePropertyTranspilerOptions } from './transpiler'; +import type { PrivatePropertyTranspileOptions, PrivatePropertyTranspilerOptions } from './transpiler'; import { Transpiler } from './transpiler'; -export type { PrivatePropertyTranspilerOptions } from './transpiler'; +export type { PrivatePropertyTranspileOptions, PrivatePropertyTranspilerOptions } from './transpiler'; export type PrivatePropertyTranspiler = { /** @@ -11,7 +11,7 @@ export type PrivatePropertyTranspiler = { * Mutates `nodes` in place and returns the `@property` rules that must be * appended to the root of the tree. */ - transpile: (nodes: Array) => Array, + transpile: (nodes: Array, options?: PrivatePropertyTranspileOptions) => Array, }; /** @@ -25,8 +25,8 @@ export function createPrivatePropertyTranspiler(options?: PrivatePropertyTranspi const transpiler = new Transpiler(options); return { - transpile(nodes: Array): Array { - return transpiler.transpile(nodes); + transpile(nodes: Array, transpileOptions?: PrivatePropertyTranspileOptions): Array { + return transpiler.transpile(nodes, transpileOptions); }, }; } diff --git a/packages/utilities-for-private-properties/src/transpiler.ts b/packages/utilities-for-private-properties/src/transpiler.ts index 0ef655abd9..9d8c67ae29 100644 --- a/packages/utilities-for-private-properties/src/transpiler.ts +++ b/packages/utilities-for-private-properties/src/transpiler.ts @@ -37,6 +37,25 @@ export type PrivatePropertyTranspilerOptions = { * private properties. */ allowUntranspiledMixins?: boolean, + /** + * Keep `@private` rules and leave references inside `@apply` and `@contents` + * blocks alone. + * + * Transpiled declarations are still hoisted, so the original notation keeps + * working where `@private` is supported. + */ + preserve?: boolean, +}; + +export type PrivatePropertyTranspileOptions = { + /** + * Style rule that owns the private property names of `nodes`. + * + * Use this when `nodes` are substituted into a style rule but are not its + * direct children, for example a `@contents` block that is authored at an + * `@apply` site and placed inside a mixin body. + */ + scope?: Rule, }; type RulePrivatePropertyNames = { @@ -47,6 +66,8 @@ type RulePrivatePropertyNames = { export class Transpiler { private privatePropertyNames: WeakMap = new WeakMap(); + private processedPrivateRules: WeakSet = new WeakSet(); + private skippedStyleRules: WeakSet = new WeakSet(); private counter = 0; @@ -55,72 +76,122 @@ export class Transpiler { private allowUntranspiledMixins: boolean; + private preserve: boolean; + private propertyRegistrations: Array = []; + private scope: Rule | undefined; + + private scopeRules: Set = new Set(); + constructor(options?: PrivatePropertyTranspilerOptions) { this.namespace = options?.namespace || 'p'; this.allowUntranspiledMixins = options?.allowUntranspiledMixins === true; + this.preserve = options?.preserve === true; } - transpile(nodes: Array): Array { - this.collectSkippedStyleRules(nodes); + transpile(nodes: Array, options?: PrivatePropertyTranspileOptions): Array { + const previousScope = this.scope; + const previousScopeRules = this.scopeRules; - for (const node of nodes) { - if (node.type === 'atrule' && IS_PRIVATE_RULE_REGEX.test(node.name)) { - this.transpilePrivateRule(node); - } + this.scope = options?.scope; + this.scopeRules = collectRules(nodes); - if (isContainer(node)) { - node.walkAtRules(IS_PRIVATE_RULE_REGEX, (atRule) => this.transpilePrivateRule(atRule)); - } - } + try { + this.collectSkippedStyleRules(nodes); - for (const node of nodes) { - if (node.type === 'decl') { - this.transpileDeclaration(node); - continue; + // Hoisted declarations can be inserted next to `nodes`, outside the + // subtree that is walked below. Keep them so their values are still + // rewritten against the correct scope. + const hoisted: Array = []; + + for (const node of nodes) { + if (node.type === 'atrule' && IS_PRIVATE_RULE_REGEX.test(node.name)) { + hoisted.push(...this.transpilePrivateRule(node)); + } + + if (isContainer(node)) { + node.walkAtRules(IS_PRIVATE_RULE_REGEX, (atRule) => { + hoisted.push(...this.transpilePrivateRule(atRule)); + }); + } } - if (isContainer(node)) { - node.walkDecls((decl) => this.transpileDeclaration(decl)); + for (const node of nodes) { + if (node.type === 'decl') { + this.transpileDeclaration(node); + continue; + } + + if (isContainer(node)) { + node.walkDecls((decl) => this.transpileDeclaration(decl)); + } } - } - for (const node of nodes) { - if (node.type === 'atrule') { - this.transpileContainerRule(node); - continue; + for (const declaration of hoisted) { + this.transpileDeclaration(declaration); } - if (isContainer(node)) { - node.walkAtRules((atRule) => this.transpileContainerRule(atRule)); + for (const node of nodes) { + if (node.type === 'atrule') { + this.transpileContainerRule(node); + continue; + } + + if (isContainer(node)) { + node.walkAtRules((atRule) => this.transpileContainerRule(atRule)); + } } - } - const registrations = this.propertyRegistrations; - this.propertyRegistrations = []; - return registrations; + const registrations = this.propertyRegistrations; + this.propertyRegistrations = []; + return registrations; + } finally { + this.scope = previousScope; + this.scopeRules = previousScopeRules; + } } - private transpilePrivateRule(atRule: AtRule): void { - const styleRule = findStyleRule(atRule); - if (!styleRule || this.isSkipped(atRule)) { - return; + private transpilePrivateRule(atRule: AtRule): Array { + const styleRule = this.ownerFor(atRule); + if (!styleRule || this.isSkipped(atRule) || this.processedPrivateRules.has(atRule)) { + return []; } + this.processedPrivateRules.add(atRule); + const rulePrivatePropertyNames = this.privatePropertyNamesForRule(styleRule); this.hoistPrivatePropertyRegistrations(atRule, rulePrivatePropertyNames); + if (this.preserve) { + const clone = atRule.clone(); + this.cleanPrivateRule(clone, rulePrivatePropertyNames); + clone.walkAtRules(IS_PROPERTY_RULE_REGEX, (propertyRule) => { + propertyRule.remove(); + }); + removeEmptyNestedGroupRules(clone); + + const hoisted = (clone.nodes || []).map((node) => node.clone()); + if (hoisted.length) { + atRule.before(hoisted); + } + + return hoisted.filter((node): node is Declaration => node.type === 'decl'); + } + this.cleanPrivateRule(atRule, rulePrivatePropertyNames); if (!atRule.nodes?.length) { this.removePrivateRule(atRule, styleRule); - return; + return []; } - atRule.before(atRule.nodes.map((node) => node.clone())); + const hoisted = atRule.nodes.map((node) => node.clone()); + atRule.before(hoisted); this.removePrivateRule(atRule, styleRule); + + return hoisted.filter((node): node is Declaration => node.type === 'decl'); } /** @@ -196,8 +267,51 @@ export class Transpiler { } } + private ownerFor(node: Node): false | Rule { + const owner = findStyleRule(node); + + if (!this.scope) { + return owner; + } + + if (!owner || !this.scopeRules.has(owner)) { + return this.scope; + } + + return owner; + } + + /** + * The style rule chain for a node, using the explicit scope when the node is + * outside the subtree that was passed to `transpile`. + */ + private styleRuleChain(node: Node): Array { + const rules: Array = []; + let focus: Node = node; + let usedScope = false; + + while (true) { + const styleRule = findStyleRule(focus, !this.preserve); + if (!styleRule) { + break; + } + + if (this.scope && !usedScope && !this.scopeRules.has(styleRule)) { + usedScope = true; + rules.push(this.scope); + focus = this.scope; + continue; + } + + rules.push(styleRule); + focus = styleRule; + } + + return rules; + } + private isSkipped(node: Node): boolean { - for (const styleRule of styleRuleAncestors(node)) { + for (const styleRule of this.styleRuleChain(node)) { if (this.skippedStyleRules.has(styleRule)) { return true; } @@ -221,7 +335,9 @@ export class Transpiler { const { wrappers } = registrationWrappers(propertyRule); - propertyRule.remove(); + if (!this.preserve) { + propertyRule.remove(); + } for (const name of originalNames) { rulePrivatePropertyNames.names.add(name); @@ -253,7 +369,7 @@ export class Transpiler { return false; } - for (const styleRule of styleRuleAncestors(node)) { + for (const styleRule of this.styleRuleChain(node)) { const rulePrivatePropertyNames = this.privatePropertyNames.get(styleRule); if (rulePrivatePropertyNames?.names.has(propertyName)) { return rulePrivatePropertyNames.prefix; @@ -268,7 +384,7 @@ export class Transpiler { return false; } - for (const styleRule of styleRuleAncestors(node)) { + for (const styleRule of this.styleRuleChain(node)) { if (this.privatePropertyNames.get(styleRule)?.names.size) { return true; } @@ -679,6 +795,25 @@ function isContainer(node: ChildNode): node is Rule | AtRule { return node.type === 'rule' || node.type === 'atrule'; } +/** Every style rule in `nodes`, including the nodes themselves. */ +function collectRules(nodes: Array): Set { + const rules: Set = new Set(); + + for (const node of nodes) { + if (node.type === 'rule') { + rules.add(node); + } + + if (isContainer(node)) { + node.walkRules((rule) => { + rules.add(rule); + }); + } + } + + return rules; +} + function findStyleRule(node: Node, transparentMixins = false): false | Rule { if (!node.parent) { return false; diff --git a/packages/utilities-for-private-properties/test/test.mjs b/packages/utilities-for-private-properties/test/test.mjs index 5c859217c3..cb6d7cd559 100644 --- a/packages/utilities-for-private-properties/test/test.mjs +++ b/packages/utilities-for-private-properties/test/test.mjs @@ -460,6 +460,79 @@ test('property registrations', async (t) => { assert.ok(first[0].params.startsWith(prefix('0', 'm'))); assert.ok(second[0].params.startsWith(prefix('1', 'm'))); }); + + await t.test('uses an explicit scope for references in a subtree', () => { + const root = postcss.parse('.a { @private { --x: 1px; } & .tmp { color: var(--x); } }', { from }); + const transpiler = createPrivatePropertyTranspiler({}); + + transpiler.transpile([root.first]); + transpiler.transpile(root.first.last.nodes, { scope: root.first }); + + assert.equal(root.toString(), `.a { ${prefix()}--x: 1px; & .tmp { color: var(${prefix()}--x); } }`); + }); + + await t.test('uses an explicit scope for private rules in a subtree', () => { + const root = postcss.parse('.a { @private { --x: 1px; } & .tmp { @private { --y: 2px; } color: var(--x) var(--y); } }', { from }); + const transpiler = createPrivatePropertyTranspiler({}); + + transpiler.transpile(root.first.last.nodes, { scope: root.first }); + transpiler.transpile([root.first]); + + assert.equal(root.toString(), `.a { ${prefix()}--x: 1px; & .tmp { ${prefix()}--y: 2px; color: var(${prefix()}--x) var(${prefix()}--y); } }`); + }); + + await t.test('rewrites values of declarations hoisted out of a flat node list', () => { + const root = postcss.parse('.a { @private { --y: 1px; } & .tmp { } }', { from }); + const transpiler = createPrivatePropertyTranspiler({}); + + transpiler.transpile([root.first]); + root.first.last.append(postcss.parse('@private { --x: var(--y); }').first); + transpiler.transpile(root.first.last.nodes, { scope: root.first }); + + assert.equal(root.toString(), `.a { ${prefix()}--y: 1px; & .tmp { ${prefix()}--x: var(${prefix()}--y) } }`); + }); + + await t.test('keeps a nested rule scope inside the subtree', () => { + const outer = prefix('0'); + const inner = prefix('1'); + + const root = postcss.parse('.a { @private { --x: 1px; } & .tmp { & .inner { @private { --y: 2px; } color: var(--y); } } }', { from }); + const transpiler = createPrivatePropertyTranspiler({}); + + transpiler.transpile([root.first]); + transpiler.transpile(root.first.last.nodes, { scope: root.first }); + + assert.equal(root.toString(), `.a { ${outer}--x: 1px; & .tmp { & .inner { ${inner}--y: 2px; color: var(${inner}--y); } } }`); + }); +}); + +test('preserve', async (t) => { + await t.test('keeps private rules and hoists declarations', () => { + const p = prefix(); + + assert.equal( + transpile('.a { @private { --x: 1px; } width: var(--x); }', { preserve: true }), + `.a { ${p}--x: 1px; @private { --x: 1px; } width: var(${p}--x); }`, + ); + }); + + await t.test('keeps registrations inside private rules', () => { + const p = prefix(); + + assert.equal( + transpile('.a { @private { @property --x : 1px; } width: var(--x); }', { preserve: true }), + `.a { @private { @property --x : 1px; } width: var(${p}--x); } @property ${p}--x : 1px`, + ); + }); + + await t.test('leaves references inside @apply and @contents alone', () => { + const p = prefix(); + + assert.equal( + transpile('.a { @private { --x: 1px; } @apply --m { color: var(--x); } @contents { color: var(--x); } }', { preserve: true, allowUntranspiledMixins: true }), + `.a { ${p}--x: 1px; @private { --x: 1px; } @apply --m { color: var(--x); } @contents { color: var(--x); } }`, + ); + }); }); test('the same private name can be registered in several layers', async (t) => { diff --git a/plugins/postcss-custom-functions/CHANGELOG.md b/plugins/postcss-custom-functions/CHANGELOG.md index c5b31f9a5a..26495cfb17 100644 --- a/plugins/postcss-custom-functions/CHANGELOG.md +++ b/plugins/postcss-custom-functions/CHANGELOG.md @@ -2,19 +2,17 @@ ### Unreleased (minor) -- Support `@property` rules for local variables, including multi-name preludes and the shorthand form, and hoist registrations out of `@container`, `@scope` and `@starting-style` -- Support local variables and registrations inside conditional rules -- Resolve local variables, `inherit()` and CSS-wide keywords in function arguments, `if()` conditions and `style()` query values -- Support empty `@function` bodies and ignore `!important` declarations in them -- Treat `@function` definitions inside `@container`, `@scope` and `@starting-style` as unconditional, matching browsers -- Keep parameter registrations and values when a local variable shadows a typed parameter or a local `@property` uses the parameter name -- Keep empty `@layer` blocks when removing unused definitions and order `@layer` rules inside `@scope` as global layers -- Preserve cascade order when definitions of the same name are inlined and do not evaluate cycles in inactive conditional rules, unused fallbacks or losing declarations -- Leave calls untouched when a definition can not be transpiled, an argument has an invalid ``, or a typed parameter in a font-relative property can not be resolved at build time +- Hoist `@property` registrations out of `@container`, `@scope` and `@starting-style`, and treat definitions there as unconditional +- Keep empty `@layer` blocks and order `@layer` rules inside `@scope` as global layers - Keep functions referenced from `@apply` and `@mixin` preludes +- Keep parameter registrations and values when a local variable shadows a typed parameter +- Leave calls untouched when a definition can not be transpiled or an argument is invalid +- Preserve cascade order when inlining duplicate definitions and skip cycles in inactive conditionals +- Resolve local variables, `inherit()` and CSS-wide keywords in arguments, `if()` conditions and `style()` queries +- Support empty `@function` bodies, ignore `!important` declarations and allow locals and registrations in conditional rules - Support trailing commas, whitespace and empty arguments in dashed-function calls -- Treat `--x:` as an empty default value, reject parameter defaults that mix `{}` blocks with other tokens, and suppress defaults when a CSS-wide keyword can be selected through a `var()` fallback -- Use `@csstools/generate-idents`, `@csstools/utilities-for-property-registrations` and `@csstools/custom-function-parser` for shared implementation +- Treat `--x:` as an empty default and reject defaults that mix `{}` blocks with other tokens +- Use `@csstools/generate-idents`, `@csstools/utilities-for-property-registrations` and `@csstools/custom-function-parser` internally ### 1.0.1 diff --git a/plugins/postcss-custom-functions/README.md b/plugins/postcss-custom-functions/README.md index 7b3e4570a4..044c73d3ab 100644 --- a/plugins/postcss-custom-functions/README.md +++ b/plugins/postcss-custom-functions/README.md @@ -44,6 +44,11 @@ generated `@property` registration. A default value that is not computationally independent (for example `1em`, `var(--x)` or `--fn()`) can not be used as an `initial-value` and makes the function unsupported. +CSS-wide keywords in arguments and defaults are resolved in the argument phase, +following the specification: `inherit` resolves to the same-named custom property +in the calling context, and the other CSS-wide keywords resolve to the +guaranteed-invalid value. + ```css @function --negative(--value) { result: calc(-1 * var(--value)); diff --git a/plugins/postcss-custom-functions/docs/README.md b/plugins/postcss-custom-functions/docs/README.md index 5ca4dbff13..8958e13d57 100644 --- a/plugins/postcss-custom-functions/docs/README.md +++ b/plugins/postcss-custom-functions/docs/README.md @@ -55,6 +55,11 @@ generated `@property` registration. A default value that is not computationally independent (for example `1em`, `var(--x)` or `--fn()`) can not be used as an `initial-value` and makes the function unsupported. +CSS-wide keywords in arguments and defaults are resolved in the argument phase, +following the specification: `inherit` resolves to the same-named custom property +in the calling context, and the other CSS-wide keywords resolve to the +guaranteed-invalid value. + ```css diff --git a/plugins/postcss-mixins/CHANGELOG.md b/plugins/postcss-mixins/CHANGELOG.md index 9a8ca9c770..696a4e2e31 100644 --- a/plugins/postcss-mixins/CHANGELOG.md +++ b/plugins/postcss-mixins/CHANGELOG.md @@ -1,5 +1,18 @@ # Changes to PostCSS Mixins +### Unreleased (minor) + +- Drop `@layer` rules from mixin bodies +- Expand `@apply` and `@contents` rules in `@contents` blocks, fallbacks and nested rules +- Generate hygienic argument and private property names +- Hoist `@property` registrations from `@private` rules out of `@container`, `@scope` and `@starting-style` +- Leave CSS-wide keyword arguments unchanged and resolve CSS-wide keywords in parameter defaults +- Leave rules, mixins and `@apply` rules unchanged when they can not be transpiled completely +- Only trim whitespace from arguments and default values +- Preserve whitespace and comments from mixin bodies +- Support trailing commas, comments, empty arguments, empty defaults and `type(*)` in parameter and argument lists +- Transpile private properties in the applying rule, nested mixins and `@contents` blocks + ### 1.1.0 _October 1, 2026_ diff --git a/plugins/postcss-mixins/README.md b/plugins/postcss-mixins/README.md index a30a2a233e..9ac4d0ea1d 100644 --- a/plugins/postcss-mixins/README.md +++ b/plugins/postcss-mixins/README.md @@ -14,8 +14,19 @@ This plugin is only a partial implementation to avoid conflicts with the final s Unsupported: - typed mixin arguments - layered `@mixin` declarations +- conditional `@mixin` declarations - mixin overrides +A mixin with an unsupported definition is left unchanged: the definition and every `@apply` of that name stay as they are. +Rules that apply such a mixin are left unchanged as well, so native support keeps working for them. +The same happens when private properties in a rule can not be transpiled completely, for example when a private property registration is inside an anonymous cascade layer. + +Private properties in the applying rule and in `@contents` blocks are transpiled together with the mixin. + +An `@apply` with a CSS-wide keyword (`inherit`, `initial`, `unset`, `revert`, `revert-layer`) as an argument is left unchanged: +browsers substitute these keywords into the property that uses the parameter, while the specification resolves them in the argument phase. +CSS-wide keywords in parameter defaults are resolved in the argument phase. + ```css @mixin --foo() { color: green; @@ -53,9 +64,9 @@ Unsupported: } .bar { - --_csstools-p-1gice1e-0--arg-0: 200; - --_csstools-p-1gice1e-1--baz: var(--_csstools-p-1gice1e-0--arg-0); - color: rgb(var(--_csstools-p-1gice1e-1--baz) 127 0); + --_csstools-mix-1gice1e-arg-0: 200; + --_csstools-m-1gice1e-0--baz: var(--_csstools-mix-1gice1e-arg-0); + color: rgb(var(--_csstools-m-1gice1e-0--baz) 127 0); } .c { @@ -151,9 +162,9 @@ postcssMixins({ preserve: true }) } .bar { - --_csstools-p-1gice1e-0--arg-0: 200; - --_csstools-p-1gice1e-1--baz: var(--_csstools-p-1gice1e-0--arg-0); - color: rgb(var(--_csstools-p-1gice1e-1--baz) 127 0); + --_csstools-mix-1gice1e-arg-0: 200; + --_csstools-m-1gice1e-0--baz: var(--_csstools-mix-1gice1e-arg-0); + color: rgb(var(--_csstools-m-1gice1e-0--baz) 127 0); @apply --bar(200); } diff --git a/plugins/postcss-mixins/dist/index.mjs b/plugins/postcss-mixins/dist/index.mjs index 8ba221d7a3..3860dbc111 100644 --- a/plugins/postcss-mixins/dist/index.mjs +++ b/plugins/postcss-mixins/dist/index.mjs @@ -1 +1 @@ -import{Rule as e,AtRule as t,Declaration as s}from"postcss";import{Transpiler as n}from"@csstools/postcss-private-rule";import{parseComponentValue as r,isTokenNode as a,isFunctionNode as o,parseCommaSeparatedListOfComponentValues as i,stringify as l,isSimpleBlockNode as u,isWhiteSpaceOrCommentNode as c}from"@csstools/css-parser-algorithms";import{tokenize as p,isTokenIdent as f,isTokenOpenCurly as d,isTokenColon as m}from"@csstools/css-tokenizer";const h=/^apply$/i,g=/!\s*important/i;function processableApplyRule(e){if(!e.params||!e.params.includes("--"))return!1;if(!isInStyleRule(e))return!1;const t=r(p({css:e.params}));let s,n=[];if(a(t)&&f(t.value))s=t.value[4].value;else{if(!o(t))return!1;{s=t.getName();const e=parseArguments(t.value);if(!e)return!1;n=e}}return!!s.startsWith("--")&&{name:s,arguments:n}}function parseArguments(e){const t=i(e.flatMap(e=>e.tokens()));if(1===t.length&&""===l([t[0]]).trim())return[];const s=[];for(const e of t){const t=(1===e.length&&u(e[0])&&d(e[0].startToken)?l([e[0].value]):l([e])).trim();if(""===t)return!1;if(g.test(t))return!1;s.push(t)}return s}const x=/^scope$/i;function isInStyleRule(e){const t=e.parent;return!(!t||"root"===t.type)&&("rule"===t.type||(!("atrule"!==t.type||!x.test(t.name))||isInStyleRule(t)))}const v=/^result$/i,y=/!\s*important/i;function processableMixinRule(e){if("mixin"!==e.name.toLowerCase())return!1;if(!e.params||!e.params.includes("--"))return!1;if(void 0===e.nodes)return!1;if(e.parent!==e.root())return!1;let t=!1;if(e.walk(e=>{"atrule"===e.type&&v.test(e.name)&&(t=!0)}),t)return!1;const s=r(p({css:e.params}));let n,i=[];if(a(s)&&f(s.value))n=s.value[4].value;else{if(!o(s))return!1;{n=s.getName();const e=parseParameters(s.value);if(!e)return!1;i=e}}return!!n.startsWith("--")&&{name:n,parameters:i}}function parseParameters(e){const t=i(e.flatMap(e=>e.tokens()));if(1===t.length&&""===l([t[0]]).trim())return[];const s=[],n=new Set;for(const e of t){let t=0;for(;t{hasMixinAncestor(e)||s.push(e)});for(const e of s)e.parent&&this.expand(e,t)}finish(){for(const e of this.desugaredNestingRules)e.replaceWith(...e.nodes||[]);this.desugaredNestingRules.clear()}expand(e,t){const s=processableApplyRule(e);if(!s)return;const n=this.mixins.get(s.name);if(!n)return;if(this.expanding.has(s.name))return;if(s.arguments.length>n.parameters.length)return;this.expanding.add(s.name);const r=this.buildBody(e,s.arguments,n);this.spendBudget(countNodes(r)),e.before(r),t||e.remove(),needsWrapper(n)&&this.transpile(r),this.replaceContents(r,void 0!==e.nodes,e.nodes||[]),this.expandNested(r),this.expanding.delete(s.name)}buildBody(s,n,r){const a=(r.atRule.nodes||[]).map(e=>e.clone());if(!needsWrapper(r))return a;const o=new e({selector:"&",source:s.source});let i,l;o.raws.semicolon=!0,this.desugaredNestingRules.add(o),r.parameters.length>0&&n.length>0&&(i=new e({selector:"&",source:s.source}),i.raws.semicolon=!0,this.desugaredNestingRules.add(i),l=new t({name:"private",source:s.source}),i.append(l),i.append(o)),r.parameters.length>0&&o.append(this.buildParameterPrivateRule(s,n,r.parameters,l));for(const e of a)o.append(e);return o.cleanRaws(),l?.nodes?.length?(i?.cleanRaws(),[i]):[o]}buildParameterPrivateRule(e,n,r,a){const o=new t({name:"private",source:e.source});for(let t=0;te.clone())),e.remove()}}spendBudget(e){if(this.generatedNodes+=e,this.generatedNodes>1e5)throw new Error("Maximum mixin expansion size exceeded, reduce the complexity of your mixins")}}function needsWrapper(e){return e.parameters.length>0||hasPrivateRules(e.atRule)}function countNodes(e){let t=0;for(const s of e)t++,"rule"!==s.type&&"atrule"!==s.type||(t+=countNodes(s.nodes||[]));return t}function hasPrivateRules(e){let t=!1;return e.walkAtRules(w,()=>{t=!0}),t}function findOwningRule(e){let t=e.parent;for(;t;){if("rule"===t.type)return t;if("atrule"!==t.type||!M.test(t.name))return!1;t=t.parent}return!1}function collectMatches(e,t,s){"atrule"===e.type&&t.test(e.name)&&s.push(e),"rule"!==e.type&&"atrule"!==e.type||e.walkAtRules(t,e=>{s.push(e)})}function collectDeclarationsAndAtRules(e,t,s){"decl"===e.type?t.push(e):"atrule"===e.type&&s.push(e),"rule"!==e.type&&"atrule"!==e.type||e.walk(e=>{"decl"===e.type?t.push(e):"atrule"===e.type&&s.push(e)})}function hasMixinAncestor(e){let t=e.parent;for(;t;){if("atrule"===t.type&&"mixin"===t.name.toLowerCase())return!0;t=t.parent}return!1}const creator=e=>{const t=Object.assign({preserve:!1},e);return{postcssPlugin:"postcss-mixins",prepare(){const e=new MixinExpander;return{postcssPlugin:"mixins",Once(s){const n=[];if(s.each(e=>{"atrule"===e.type&&n.push(e)}),e.registerMixins(n),!t.preserve)for(const t of e.registeredMixins())t.atRule.remove();e.expandAll(s,!0===t.preserve),e.finish()}}}}};creator.postcss=!0;export{creator as default,creator as"module.exports"}; +import{parseComponentValue as e,isTokenNode as t,isFunctionNode as n,stringify as s}from"@csstools/css-parser-algorithms";import{tokenize as r,isTokenEOF as o,isTokenWhiteSpaceOrComment as i,isTokenIdent as a}from"@csstools/css-tokenizer";import{parseDashedFunctionArguments as l,parseFunctionParameters as u}from"@csstools/custom-function-parser";import{generateUniqueDashedIdent as p,hashFileBasenameAndDir as c}from"@csstools/generate-idents";import{createPrivatePropertyTranspiler as d}from"@csstools/utilities-for-private-properties";function rawParams(e){const t=e.raws.params;return t&&t.value===e.params?t.raw:e.params}function preludeTokens(e){const t=r({css:e}).filter(e=>!o(e));let n=0,s=t.length;for(;nn&&i(t[s-1]);)s--;return t.slice(n,s)}const f=/^apply$/i,h=/^(container|layer|media|scope|starting-style|supports)$/i,m=/^(inherit|initial|unset|revert|revert-layer)$/i,g=/^keyframes$/i;function processableApplyRule(e){return!!applySiteRule(e)&&processableApplyPrelude(e)}function processableApplyPrelude(r){if(!r.params)return!1;const o=e(preludeTokens(rawParams(r)));let i,u=[];if(t(o)&&a(o.value))i=o.value[4].value;else{if(!n(o))return!1;{i=o.getName();const e=l(o.value);if(!e)return!1;u=e.map(e=>s([e]))}}return!!i.startsWith("--")&&{name:i,arguments:u}}function hasCSSWideKeywordArgument(e){return e.arguments.some(isCSSWideKeyword)}function isCSSWideKeyword(e){const t=preludeTokens(e);return 1===t.length&&a(t[0])&&m.test(t[0][4].value)}function applySiteRule(e){let t=e.parent;for(;t;){if("rule"===t.type)return isKeyframesRule(t)?null:t;if("atrule"!==t.type||!h.test(t.name))return null;t=t.parent}return null}function isKeyframesRule(e){let t=e?.parent;for(;t;){if("atrule"===t.type&&g.test(t.name))return!0;t=t.parent}return!1}function dashedNameFromParams(s){if(!s)return null;const r=e(preludeTokens(s));let o;if(t(r)&&a(r.value))o=r.value[4].value;else{if(!n(r))return null;o=r.getName()}return o.startsWith("--")?o:null}function mixinRuleName(e){return"mixin"!==e.name.toLowerCase()?null:dashedNameFromParams(rawParams(e))}function processableMixinRule(t){const s=mixinRuleName(t);if(!s)return!1;if(void 0===t.nodes)return!1;if(t.parent!==t.root())return!1;const r=e(preludeTokens(rawParams(t)));let o=[];if(n(r)){const e=u(r.value);if(!e||e.some(e=>{const t=e.getParameterType();return!!t&&"*"!==t}))return!1;o=e.map(e=>({name:e.getName(),defaultValue:e.getDefaultValue()??void 0}))}return{name:s,parameters:o}}function collectMixinDefinitions(e){const t=new Map;for(const n of e){const e=mixinRuleName(n);if(!e)continue;const s=t.get(e)??[];s.push(n),t.set(e,s)}const n=new Map,s=new Set,r=new Map;for(const[e,o]of t){if(1!==o.length){s.add(e);continue}const t=processableMixinRule(o[0]);if(!t||hasCSSWideKeywordApply(o[0])){s.add(e);continue}n.set(e,Object.assign({},t,{atRule:o[0]}));const i=new Set;collectApplyNames(o[0],new Set,i),r.set(e,i)}const o=new Map,isTranspilable=e=>{const t=o.get(e);if(void 0!==t)return t;if(!n.has(e))return!s.has(e);o.set(e,!1);let i=!0;for(const t of r.get(e)??[])if(!isTranspilable(t)){i=!1;break}return o.set(e,i),i};for(const e of[...n.keys()])isTranspilable(e)||(n.delete(e),s.add(e));return{mixins:n,unsupported:s}}function removeUnusedMixins(e,t){const n=new Set;for(const e of t.mixins.values())n.add(e.atRule);const s=new Set;collectApplyNames(e,n,s);const r=new Set,o=[...s];for(;o.length;){const e=o.pop();if(r.has(e))continue;r.add(e);const n=t.mixins.get(e);if(!n)continue;const i=new Set;collectApplyNames(n.atRule,new Set,i);for(const e of i)s.has(e)||(s.add(e),o.push(e))}for(const[e,n]of t.mixins)s.has(e)||n.atRule.remove()}function collectApplyNames(e,t,n){e.walkAtRules(f,e=>{if(isInsideAny(e,t))return;const s=dashedNameFromParams(rawParams(e));s&&n.add(s)})}function isInsideAny(e,t){let n=e;for(;n;){if(t.has(n))return!0;n=n.parent}return!1}function hasCSSWideKeywordApply(e){let t=!1;return e.walkAtRules(f,e=>{if(t)return;const n=processableApplyPrelude(e);n&&hasCSSWideKeywordArgument(n)&&(t=!0)}),t}const y=/^contents$/i,R=/^layer$/i,x=/^private$/i,v=/^(initial|unset|revert|revert-layer)$/i,w=/^inherit$/i,S="initial";class MixinExpander{definitions;preserve;expansionTranspiler;authorTranspiler;registrations=[];argumentCounter=0;desugaredNestingRules=new Set;expansionRules=new Set;applyingRules=new Set;generatedNodes=0;constructor(e,t){this.definitions=e,this.preserve=t,this.expansionTranspiler=d({namespace:"m",allowUntranspiledMixins:!0}),this.authorTranspiler=d({namespace:"p",allowUntranspiledMixins:!0,preserve:t})}expandAll(e,t){this.generatedNodes=0;const n=[];e.walkAtRules(f,e=>{hasMixinAncestor(e)||n.push(e)});const s=new Map;for(const e of n){if(!processableApplyRule(e))continue;const t=applySiteRule(e);if(!t)continue;const n=s.get(t)??[];n.push(e),s.set(t,n)}const r=new Set;for(const[e,t]of s)for(const n of t){const t=processableApplyRule(n);if(t&&(this.definitions.unsupported.has(t.name)||this.hasUnsupportedArguments(t))){blockRuleAndAncestors(e,r);break}}for(const[e,n]of s){if(isBlocked(e,r))continue;const s=[];let o=!1,i=!1;for(const e of n){const n=this.expand(e,this.preserve,t,s);"expanded"===n?o=!0:"bailed"===n&&(i=!0)}if(i)for(let e=s.length-1;e>=0;e--)this.rollback(s[e]);else if(o){for(const e of s)e.atRule.remove();collectRuleAndAncestors(e,this.applyingRules)}}}finish(e){for(const e of this.desugaredNestingRules)e.replaceWith(...e.nodes||[]);this.desugaredNestingRules.clear();for(const e of this.applyingRules)isOutermost(e,this.applyingRules)&&this.registrations.push(...this.authorTranspiler.transpile([e]));this.applyingRules.clear(),this.expansionRules.clear(),e.append(...this.registrations),this.registrations=[]}expand(e,t,n,s){const r=processableApplyRule(e);if(!r)return"ignored";const o=this.definitions.mixins.get(r.name);if(!o)return this.definitions.unsupported.has(r.name)?"bailed":"ignored";if(r.arguments.length>o.parameters.length)return"ignored";if(this.hasUnsupportedArguments(r))return"bailed";const i=applySiteRule(e),a=void 0!==e.nodes,l=this.buildBody(e,r.arguments,o,n),u={atRule:e,inserted:l,substituted:[],registrations:this.registrations.length,desugaredNestingRules:this.desugaredNestingRules.size,expansionRules:this.expansionRules.size,generatedNodes:this.generatedNodes};this.spendBudget(countNodes(l)),e.before(l),this.registerExpansionRules(l),this.transpileExpansion(l),u.substituted=this.replaceContents(l,a,e.nodes||[],i);const p=this.expandNested([...l,...u.substituted],n);return t||"bailed"!==p&&!hasPrivateRule(l)&&!hasPrivateRule(u.substituted)?t?"expanded":s?(s.push(u),"expanded"):(e.remove(),"expanded"):(this.rollback(u),"bailed")}rollback(e){for(const t of e.inserted)t.remove();for(const t of e.substituted)t.remove();this.registrations.length=e.registrations,trimSet(this.desugaredNestingRules,e.desugaredNestingRules),trimSet(this.expansionRules,e.expansionRules),this.generatedNodes=e.generatedNodes}buildBody(e,t,n,s){const r=cloneMixinBodyNodes(n.atRule);if(!needsWrapper(n))return r;const o=[],i=[];for(let r=0;r0&&a.append(this.buildParameterPrivateRule(e,n.parameters,i,s));for(const e of r)a.append(e);return[l]}argumentName(e){return p("mix",c(e.source?.input.from),"arg-"+this.argumentCounter++)}hasUnsupportedArguments(e){const t=this.definitions.mixins.get(e.name);return!(!t||e.arguments.length>t.parameters.length)&&hasCSSWideKeywordArgument(e)}buildParameterPrivateRule(e,t,n,s){const r=s.atRule({name:"private",source:e.source});for(let o=0;oe.clone());e.before(a),e.remove(),this.registerExpansionRules(a),!r&&s?this.transpileContents(a,s):this.transpileExpansion(a),o.push(...a),r&&o.push(...this.replaceContents(a,t,n,s))}return o}registerExpansionRules(e){for(const t of e)"rule"===t.type&&this.expansionRules.add(t),"rule"!==t.type&&"atrule"!==t.type||t.walkRules(e=>{this.expansionRules.add(e)})}spendBudget(e){if(this.generatedNodes+=e,this.generatedNodes>1e5)throw new Error("Maximum mixin expansion size exceeded, reduce the complexity of your mixins")}}function needsWrapper(e){return e.parameters.length>0||hasPrivateRules(e.atRule)}function isInheritKeyword(e){return isSingleKeyword(e,w)}function isSingleKeyword(e,t){if(void 0===e)return!1;const n=preludeTokens(e);return 1===n.length&&a(n[0])&&t.test(n[0][4].value)}function defaultParameterValue(e){return void 0===e.defaultValue?S:isSingleKeyword(e.defaultValue,v)?S:e.defaultValue}function cloneMixinBodyNodes(e){const t=[];for(const n of e.nodes||[]){if("atrule"===n.type&&R.test(n.name))continue;const e=n.clone();"rule"!==e.type&&"atrule"!==e.type||e.walkAtRules(R,e=>{e.remove()}),t.push(e)}return t}function countNodes(e){let t=0;for(const n of e)t++,"rule"!==n.type&&"atrule"!==n.type||(t+=countNodes(n.nodes||[]));return t}function hasPrivateRules(e){let t=!1;return e.walkAtRules(x,()=>{t=!0}),t}function hasPrivateRule(e){for(const t of e)if(t.parent){if("atrule"===t.type&&x.test(t.name))return!0;if(("rule"===t.type||"atrule"===t.type)&&hasPrivateRule(t.nodes||[]))return!0}return!1}function collectContentsRules(e,t){for(const n of e)"atrule"===n.type&&y.test(n.name)?t.push(n):"rule"!==n.type&&"atrule"!==n.type||collectContentsRules(n.nodes||[],t)}function collectMatches(e,t,n){e.parent&&("atrule"===e.type&&t.test(e.name)&&n.add(e),"rule"!==e.type&&"atrule"!==e.type||e.walkAtRules(t,e=>{n.add(e)}))}function trimSet(e,t){if(e.size<=t)return;const n=[...e];for(let s=t;s{const t=Object.assign({preserve:!1},e);return{postcssPlugin:"postcss-mixins",Once(e,n){const s=[];e.walkAtRules(e=>{s.push(e)});const r=collectMixinDefinitions(s),o=new MixinExpander(r,!0===t.preserve);o.expandAll(e,n),o.finish(e),t.preserve||removeUnusedMixins(e,r)}}};creator.postcss=!0;export{creator as default,creator as"module.exports"}; diff --git a/plugins/postcss-mixins/docs/README.md b/plugins/postcss-mixins/docs/README.md index e29a67ed77..230c4985f8 100644 --- a/plugins/postcss-mixins/docs/README.md +++ b/plugins/postcss-mixins/docs/README.md @@ -25,8 +25,19 @@ This plugin is only a partial implementation to avoid conflicts with the final s Unsupported: - typed mixin arguments - layered `@mixin` declarations +- conditional `@mixin` declarations - mixin overrides +A mixin with an unsupported definition is left unchanged: the definition and every `@apply` of that name stay as they are. +Rules that apply such a mixin are left unchanged as well, so native support keeps working for them. +The same happens when private properties in a rule can not be transpiled completely, for example when a private property registration is inside an anonymous cascade layer. + +Private properties in the applying rule and in `@contents` blocks are transpiled together with the mixin. + +An `@apply` with a CSS-wide keyword (`inherit`, `initial`, `unset`, `revert`, `revert-layer`) as an argument is left unchanged: +browsers substitute these keywords into the property that uses the parameter, while the specification resolves them in the argument phase. +CSS-wide keywords in parameter defaults are resolved in the argument phase. + ```css diff --git a/plugins/postcss-mixins/package.json b/plugins/postcss-mixins/package.json index cea31fb7f6..1baf85c47d 100644 --- a/plugins/postcss-mixins/package.json +++ b/plugins/postcss-mixins/package.json @@ -43,7 +43,9 @@ "dependencies": { "@csstools/css-parser-algorithms": "^4.0.2", "@csstools/css-tokenizer": "^4.0.2", - "@csstools/postcss-private-rule": "^1.0.3" + "@csstools/custom-function-parser": "^1.0.0", + "@csstools/generate-idents": "^0.0.0", + "@csstools/utilities-for-private-properties": "^0.0.0" }, "peerDependencies": { "postcss": "^8.4" diff --git a/plugins/postcss-mixins/src/index.ts b/plugins/postcss-mixins/src/index.ts index 33f3f2b9bd..9202ac1547 100644 --- a/plugins/postcss-mixins/src/index.ts +++ b/plugins/postcss-mixins/src/index.ts @@ -1,4 +1,5 @@ -import type { AtRule, Plugin, PluginCreator } from 'postcss'; +import type { AtRule, PluginCreator } from 'postcss'; +import { collectMixinDefinitions, removeUnusedMixins } from './mixin-definitions'; import { MixinExpander } from './mixin-expander'; /** postcss-mixins plugin options */ @@ -19,31 +20,21 @@ const creator: PluginCreator = (opts?: pluginOptions) => { return { postcssPlugin: 'postcss-mixins', - prepare(): Plugin { - const expander = new MixinExpander(); - - return { - postcssPlugin: 'mixins', - Once(root): void { - const rootAtRules: Array = []; - root.each((child) => { - if (child.type === 'atrule') { - rootAtRules.push(child); - } - }); - - expander.registerMixins(rootAtRules); - - if (!options.preserve) { - for (const mixin of expander.registeredMixins()) { - mixin.atRule.remove(); - } - } - - expander.expandAll(root, options.preserve === true); - expander.finish(); - }, - }; + Once(root, helpers): void { + const atRules: Array = []; + root.walkAtRules((atRule) => { + atRules.push(atRule); + }); + + const definitions = collectMixinDefinitions(atRules); + const expander = new MixinExpander(definitions, options.preserve === true); + + expander.expandAll(root, helpers); + expander.finish(root); + + if (!options.preserve) { + removeUnusedMixins(root, definitions); + } }, }; }; diff --git a/plugins/postcss-mixins/src/mixin-definitions.ts b/plugins/postcss-mixins/src/mixin-definitions.ts new file mode 100644 index 0000000000..486b12118f --- /dev/null +++ b/plugins/postcss-mixins/src/mixin-definitions.ts @@ -0,0 +1,205 @@ +import type { AtRule, Container, Document, Node, Root } from 'postcss'; +import { hasCSSWideKeywordArgument, IS_APPLY_REGEX, processableApplyPrelude } from './processable-apply'; +import type { MixinParameter } from './processable-mixin'; +import { dashedNameFromParams, mixinRuleName, processableMixinRule } from './processable-mixin'; +import { rawParams } from './utils'; + +export type Mixin = { + name: string, + parameters: Array, + atRule: AtRule, +}; + +export type MixinDefinitions = { + /** Names that can be transpiled. */ + mixins: Map, + /** Names with at least one definition that can not be transpiled. */ + unsupported: Set, +}; + +/** + * Group `@mixin` rules by name. + * + * A name is only transpilable when it has exactly one definition, that + * definition can be transpiled, and everything it applies can be transpiled as + * well. Otherwise every definition and every `@apply` of that name is left + * untouched. + */ +export function collectMixinDefinitions(atRules: Array): MixinDefinitions { + const byName: Map> = new Map(); + + for (const atRule of atRules) { + const name = mixinRuleName(atRule); + if (!name) { + continue; + } + + const definitions = byName.get(name) ?? []; + definitions.push(atRule); + byName.set(name, definitions); + } + + const mixins: Map = new Map(); + const unsupported: Set = new Set(); + const references: Map> = new Map(); + + for (const [name, definitions] of byName) { + if (definitions.length !== 1) { + unsupported.add(name); + continue; + } + + const parsed = processableMixinRule(definitions[0]); + if (!parsed || hasCSSWideKeywordApply(definitions[0])) { + unsupported.add(name); + continue; + } + + mixins.set(name, Object.assign({}, parsed, { atRule: definitions[0] })); + + const names: Set = new Set(); + collectApplyNames(definitions[0], new Set(), names); + references.set(name, names); + } + + // A mixin that applies a mixin which can not be transpiled can not be + // transpiled either. A cycle makes every mixin on the cycle unsupported. + const state: Map = new Map(); + + const isTranspilable = (name: string): boolean => { + const known = state.get(name); + if (known !== undefined) { + return known; + } + + if (!mixins.has(name)) { + return !unsupported.has(name); + } + + // Assume a cycle until proven otherwise. + state.set(name, false); + + let transpilable = true; + for (const reference of references.get(name) ?? []) { + if (!isTranspilable(reference)) { + transpilable = false; + break; + } + } + + state.set(name, transpilable); + return transpilable; + }; + + for (const name of [...mixins.keys()]) { + if (isTranspilable(name)) { + continue; + } + + mixins.delete(name); + unsupported.add(name); + } + + return { mixins, unsupported }; +} + +/** + * Remove definitions of mixins that are not referenced by any `@apply` rule + * that remains in the output. + * + * A definition is only removed when every call site is expanded by this plugin. + * Call sites that are left as-is, for example inside a preserved `@mixin`, keep + * their definitions alive. + */ +export function removeUnusedMixins(root: Root, definitions: MixinDefinitions): void { + const supportedNodes: Set = new Set(); + for (const mixin of definitions.mixins.values()) { + supportedNodes.add(mixin.atRule); + } + + const required: Set = new Set(); + collectApplyNames(root, supportedNodes, required); + + // Definitions that are kept can reference other definitions. + const processed: Set = new Set(); + const queue: Array = [...required]; + + while (queue.length) { + const name = queue.pop() as string; + if (processed.has(name)) { + continue; + } + + processed.add(name); + + const mixin = definitions.mixins.get(name); + if (!mixin) { + continue; + } + + const references: Set = new Set(); + collectApplyNames(mixin.atRule, new Set(), references); + + for (const reference of references) { + if (required.has(reference)) { + continue; + } + + required.add(reference); + queue.push(reference); + } + } + + for (const [name, mixin] of definitions.mixins) { + if (required.has(name)) { + continue; + } + + mixin.atRule.remove(); + } +} + +function collectApplyNames(container: Container | Document, skipNodes: Set, out: Set): void { + container.walkAtRules(IS_APPLY_REGEX, (atRule) => { + if (isInsideAny(atRule, skipNodes)) { + return; + } + + const name = dashedNameFromParams(rawParams(atRule)); + if (name) { + out.add(name); + } + }); +} + +function isInsideAny(node: Node, nodes: Set): boolean { + let parent: Node | undefined = node; + + while (parent) { + if (nodes.has(parent)) { + return true; + } + + parent = parent.parent; + } + + return false; +} + +/** Whether an `@apply` rule inside a mixin body has a CSS-wide keyword argument. */ +function hasCSSWideKeywordApply(container: Container): boolean { + let found = false; + + container.walkAtRules(IS_APPLY_REGEX, (atRule) => { + if (found) { + return; + } + + const apply = processableApplyPrelude(atRule); + if (apply && hasCSSWideKeywordArgument(apply)) { + found = true; + } + }); + + return found; +} diff --git a/plugins/postcss-mixins/src/mixin-expander.ts b/plugins/postcss-mixins/src/mixin-expander.ts index c0567885b9..397d484491 100644 --- a/plugins/postcss-mixins/src/mixin-expander.ts +++ b/plugins/postcss-mixins/src/mixin-expander.ts @@ -1,66 +1,70 @@ -import { AtRule, Declaration, Rule } from 'postcss'; -import type { ChildNode, Node, Root } from 'postcss'; -import { Transpiler } from '@csstools/postcss-private-rule'; -import { IS_APPLY_REGEX, processableApplyRule } from './processable-apply'; +import type { AtRule, ChildNode, Helpers, Root, Rule } from 'postcss'; +import { generateUniqueDashedIdent, hashFileBasenameAndDir } from '@csstools/generate-idents'; +import { isTokenIdent } from '@csstools/css-tokenizer'; +import type { PrivatePropertyTranspiler } from '@csstools/utilities-for-private-properties'; +import { createPrivatePropertyTranspiler } from '@csstools/utilities-for-private-properties'; +import type { Mixin, MixinDefinitions } from './mixin-definitions'; +import type { ProcessableApply } from './processable-apply'; +import { hasCSSWideKeywordArgument, IS_APPLY_REGEX, IS_NESTING_GROUP_RULE_REGEX, applySiteRule, processableApplyRule } from './processable-apply'; import type { MixinParameter } from './processable-mixin'; -import { processableMixinRule } from './processable-mixin'; - -type Mixin = { - name: string, - parameters: Array, - atRule: AtRule, -}; +import { preludeTokens } from './utils'; const IS_CONTENTS_REGEX = /^contents$/i; +const IS_LAYER_REGEX = /^layer$/i; const IS_PRIVATE_REGEX = /^private$/i; -const IS_NESTING_GROUP_RULE_REGEX = /^(container|layer|media|scope|starting-style|supports)$/i; +const IS_GUARANTEED_INVALID_KEYWORD_REGEX = /^(initial|unset|revert|revert-layer)$/i; +const IS_INHERIT_KEYWORD_REGEX = /^inherit$/i; + +const ARGUMENT_NAMESPACE = 'mix'; + +/** `initial` on an unregistered custom property resolves to the guaranteed-invalid value. */ +const GUARANTEED_INVALID_VALUE = 'initial'; // Mixins can reference each other and duplicate subtrees, which can grow // exponentially. Bound the total number of nodes generated while expanding // mixins so that a small stylesheet can not exhaust memory or CPU. const MAX_GENERATED_NODES = 100_000; +type ExpandResult = 'bailed' | 'expanded' | 'ignored'; + +type Expansion = { + atRule: AtRule, + inserted: Array, + substituted: Array, + registrations: number, + desugaredNestingRules: number, + expansionRules: number, + generatedNodes: number, +}; + /** * Deepens mixin expansion behind a small interface: - * register the mixins once, expand the top level `@apply` rules, then finish. + * expand the `@apply` rules of one stylesheet, then finish. * - * Everything else — argument capture, wrapper construction, private scoping, - * `@contents` substitution, nested recursion and the cycle guard — is internal. + * Everything else — argument capture, wrapper construction, private scoping and + * `@contents` substitution — is internal. */ export class MixinExpander { - private mixins: Map = new Map(); - private knownMixins: Set = new Set(); - private transpiler: Transpiler = new Transpiler(); + private definitions: MixinDefinitions; + private preserve: boolean; + private expansionTranspiler: PrivatePropertyTranspiler; + private authorTranspiler: PrivatePropertyTranspiler; + private registrations: Array = []; private argumentCounter = 0; private desugaredNestingRules: Set = new Set(); - private expanding: Set = new Set(); + private expansionRules: Set = new Set(); + private applyingRules: Set = new Set(); private generatedNodes = 0; - /** The mixin at rules that were registered, so a caller can remove or preserve them. */ - registeredMixins(): Array { - return Array.from(this.mixins.values()); - } - - registerMixins(rootAtRules: Array): void { - for (const atRule of rootAtRules) { - const parsed = processableMixinRule(atRule); - if (!parsed) { - continue; - } - - // TODO: support mixin overrides - if (this.knownMixins.has(parsed.name)) { - this.mixins.delete(parsed.name); - continue; - } - - this.mixins.set(parsed.name, Object.assign({}, parsed, { atRule })); - this.knownMixins.add(parsed.name); - } + constructor(definitions: MixinDefinitions, preserve: boolean) { + this.definitions = definitions; + this.preserve = preserve; + this.expansionTranspiler = createPrivatePropertyTranspiler({ namespace: 'm', allowUntranspiledMixins: true }); + this.authorTranspiler = createPrivatePropertyTranspiler({ namespace: 'p', allowUntranspiledMixins: true, preserve }); } - /** Expands all top level `@apply` rules in `root`, except those authored inside a `@mixin`. */ - expandAll(root: Root, preserve: boolean): void { + /** Expands all `@apply` rules in `root`, except those authored inside a `@mixin`. */ + expandAll(root: Root, helpers: Helpers): void { this.generatedNodes = 0; const applies: Array = []; @@ -72,48 +76,143 @@ export class MixinExpander { applies.push(atRule); }); + const appliesByRule: Map> = new Map(); for (const atRule of applies) { - if (!atRule.parent) { + const apply = processableApplyRule(atRule); + if (!apply) { + continue; + } + + const rule = applySiteRule(atRule); + if (!rule) { continue; } - this.expand(atRule, preserve); + const ruleApplies = appliesByRule.get(rule) ?? []; + ruleApplies.push(atRule); + appliesByRule.set(rule, ruleApplies); + } + + // A rule with an `@apply` for a mixin that can not be transpiled must stay + // untouched, together with every rule it is nested in. Expanding the other + // rules that still apply to the same elements would either drop styles or + // mix native and transpiled output. + const blocked: Set = new Set(); + for (const [rule, ruleApplies] of appliesByRule) { + for (const atRule of ruleApplies) { + const apply = processableApplyRule(atRule); + if (!apply) { + continue; + } + + if (!this.definitions.unsupported.has(apply.name) && !this.hasUnsupportedArguments(apply)) { + continue; + } + + blockRuleAndAncestors(rule, blocked); + break; + } + } + + for (const [rule, ruleApplies] of appliesByRule) { + if (isBlocked(rule, blocked)) { + continue; + } + + const expansions: Array = []; + let expanded = false; + let bailed = false; + + for (const atRule of ruleApplies) { + const result = this.expand(atRule, this.preserve, helpers, expansions); + if (result === 'expanded') { + expanded = true; + } else if (result === 'bailed') { + bailed = true; + } + } + + if (bailed) { + for (let i = expansions.length - 1; i >= 0; i--) { + this.rollback(expansions[i]); + } + + continue; + } + + if (!expanded) { + continue; + } + + for (const expansion of expansions) { + expansion.atRule.remove(); + } + + collectRuleAndAncestors(rule, this.applyingRules); } } - /** Removes the temporary `& {}` nesting rules created while desugaring. */ - finish(): void { + /** Removes temporary wrappers, transpiles private properties and appends registrations to the root. */ + finish(root: Root): void { for (const wrapper of this.desugaredNestingRules) { wrapper.replaceWith(...wrapper.nodes || []); } this.desugaredNestingRules.clear(); + + for (const rule of this.applyingRules) { + if (!isOutermost(rule, this.applyingRules)) { + continue; + } + + this.registrations.push(...this.authorTranspiler.transpile([rule])); + } + + this.applyingRules.clear(); + this.expansionRules.clear(); + + root.append(...this.registrations); + this.registrations = []; } - private expand(atRule: AtRule, preserve: boolean): void { + private expand(atRule: AtRule, preserve: boolean, helpers: Helpers, deferred?: Array): ExpandResult { const apply = processableApplyRule(atRule); if (!apply) { - return; + return 'ignored'; } - const mixin = this.mixins.get(apply.name); + const mixin = this.definitions.mixins.get(apply.name); if (!mixin) { - return; - } - - // Guard against mixins that (indirectly) apply themselves. - if (this.expanding.has(apply.name)) { - return; + // An unsupported mixin still works in browsers with native support. + return this.definitions.unsupported.has(apply.name) ? 'bailed' : 'ignored'; } // Passing more arguments than the mixin accepts is invalid. + // The application does nothing, so the `@apply` rule is left in place. if (apply.arguments.length > mixin.parameters.length) { - return; + return 'ignored'; } - this.expanding.add(apply.name); + // CSS-wide keywords are resolved differently by browsers and the + // specification, so these applications are left in place. + if (this.hasUnsupportedArguments(apply)) { + return 'bailed'; + } + + const siteRule = applySiteRule(atRule); + const hasContents = atRule.nodes !== undefined; + + const inserted = this.buildBody(atRule, apply.arguments, mixin, helpers); - const inserted = this.buildBody(atRule, apply.arguments, mixin); + const expansion: Expansion = { + atRule, + inserted, + substituted: [], + registrations: this.registrations.length, + desugaredNestingRules: this.desugaredNestingRules.size, + expansionRules: this.expansionRules.size, + generatedNodes: this.generatedNodes, + }; this.spendBudget(countNodes(inserted)); @@ -121,26 +220,55 @@ export class MixinExpander { // `indexOf` for every single `before()` call, which is quadratic. atRule.before(inserted); - if (!preserve) { - atRule.remove(); + this.registerExpansionRules(inserted); + this.transpileExpansion(inserted); + + // `@contents` is substituted after insertion so the replaced at-rule has a parent. + expansion.substituted = this.replaceContents(inserted, hasContents, atRule.nodes || [], siteRule); + + const nested = this.expandNested([...inserted, ...expansion.substituted], helpers); + + // A `@private` rule that is left behind means that a rule could not be + // transpiled completely. Leave the application untouched so that native + // support keeps working for it, instead of dropping the `@apply`. + if (!preserve && (nested === 'bailed' || hasPrivateRule(inserted) || hasPrivateRule(expansion.substituted))) { + this.rollback(expansion); + return 'bailed'; } - if (needsWrapper(mixin)) { - this.transpile(inserted); + if (preserve) { + return 'expanded'; } - // `@contents` is substituted after insertion so the replaced at-rule has a parent. - // It is substituted after transpilation so passed-in contents are not scoped to the mixin. - this.replaceContents(inserted, atRule.nodes !== undefined, atRule.nodes || []); + if (deferred) { + deferred.push(expansion); + return 'expanded'; + } + + atRule.remove(); + + return 'expanded'; + } + + /** Undo an expansion that can not be committed. */ + private rollback(expansion: Expansion): void { + for (const node of expansion.inserted) { + node.remove(); + } - this.expandNested(inserted); + for (const node of expansion.substituted) { + node.remove(); + } - this.expanding.delete(apply.name); + this.registrations.length = expansion.registrations; + trimSet(this.desugaredNestingRules, expansion.desugaredNestingRules); + trimSet(this.expansionRules, expansion.expansionRules); + this.generatedNodes = expansion.generatedNodes; } /** Captures arguments, scopes parameters and `@private` rules, and returns the nodes to insert. */ - private buildBody(atRule: AtRule, args: Array, mixin: Mixin): Array { - const cloned: Array = (mixin.atRule.nodes || []).map((node) => node.clone()); + private buildBody(atRule: AtRule, args: Array, mixin: Mixin, helpers: Helpers): Array { + const cloned = cloneMixinBodyNodes(mixin.atRule); if (!needsWrapper(mixin)) { return cloned; @@ -150,68 +278,93 @@ export class MixinExpander { // Each supplied argument is bound to a fresh custom property so it can not be // shadowed by parameters of nested mixins that reuse the same names. // See: https://github.com/w3c/csswg-drafts/issues/14372 - const bodyWrapper = new Rule({ selector: '&', source: atRule.source }); + // + // The bindings are plain declarations, not `@private` rules, so they keep the + // generated name instead of being prefixed a second time. + const bindings: Array = []; + const argumentNames: Array = []; + + for (let i = 0; i < mixin.parameters.length; i++) { + const parameter = mixin.parameters[i]; + + if (i < args.length) { + const argumentName = this.argumentName(atRule); + argumentNames[i] = argumentName; + bindings.push(helpers.decl({ + prop: argumentName, + value: args[i], + source: atRule.source, + })); + continue; + } + + // `inherit` on a parameter default resolves to the same-named custom + // property in the calling context. + if (isInheritKeyword(parameter.defaultValue)) { + const argumentName = this.argumentName(atRule); + argumentNames[i] = argumentName; + bindings.push(helpers.decl({ + prop: argumentName, + value: `var(${parameter.name})`, + source: atRule.source, + })); + } + } + + const bodyWrapper = helpers.rule({ selector: '&', source: atRule.source }); bodyWrapper.raws.semicolon = true; this.desugaredNestingRules.add(bodyWrapper); - let outerWrapper: Rule | undefined; - let argumentPrivateRule: AtRule | undefined; + let wrapper: Rule = bodyWrapper; + + if (bindings.length) { + const argumentsWrapper = helpers.rule({ selector: '&', source: atRule.source }); + argumentsWrapper.raws.semicolon = true; + this.desugaredNestingRules.add(argumentsWrapper); - if (mixin.parameters.length > 0 && args.length > 0) { - outerWrapper = new Rule({ selector: '&', source: atRule.source }); - outerWrapper.raws.semicolon = true; - this.desugaredNestingRules.add(outerWrapper); + argumentsWrapper.append(bindings); + argumentsWrapper.append(bodyWrapper); - argumentPrivateRule = new AtRule({ name: 'private', source: atRule.source }); - outerWrapper.append(argumentPrivateRule); - outerWrapper.append(bodyWrapper); + wrapper = argumentsWrapper; } if (mixin.parameters.length > 0) { - bodyWrapper.append(this.buildParameterPrivateRule(atRule, args, mixin.parameters, argumentPrivateRule)); + bodyWrapper.append(this.buildParameterPrivateRule(atRule, mixin.parameters, argumentNames, helpers)); } for (const node of cloned) { bodyWrapper.append(node); } - bodyWrapper.cleanRaws(); + return [wrapper]; + } + + private argumentName(atRule: AtRule): string { + return generateUniqueDashedIdent(ARGUMENT_NAMESPACE, hashFileBasenameAndDir(atRule.source?.input.from), `arg-${this.argumentCounter++}`); + } - if (!argumentPrivateRule?.nodes?.length) { - return [bodyWrapper]; + /** Whether an application can not be transpiled because of the arguments it passes. */ + private hasUnsupportedArguments(apply: ProcessableApply): boolean { + const mixin = this.definitions.mixins.get(apply.name); + if (!mixin || apply.arguments.length > mixin.parameters.length) { + return false; } - outerWrapper?.cleanRaws(); - - return [outerWrapper as Rule]; + return hasCSSWideKeywordArgument(apply); } /** Binds each parameter to its captured argument value, or to its default in the mixin's frame. */ - private buildParameterPrivateRule(atRule: AtRule, args: Array, parameters: Array, argumentPrivateRule?: AtRule): AtRule { - const parameterPrivateRule = new AtRule({ name: 'private', source: atRule.source }); + private buildParameterPrivateRule(atRule: AtRule, parameters: Array, argumentNames: Array, helpers: Helpers): AtRule { + const parameterPrivateRule = helpers.atRule({ name: 'private', source: atRule.source }); for (let i = 0; i < parameters.length; i++) { const parameter = parameters[i]; + const argumentName = argumentNames[i]; - let value; - - if (i < args.length) { - const argumentName = `--arg-${(this.argumentCounter++).toString(36)}`; - - argumentPrivateRule?.append(new Declaration({ - prop: argumentName, - value: args[i], - source: atRule.source, - })); - - // The parameter resolves to the captured argument value. - value = `var(${argumentName})`; - } else { - // Missing arguments resolve to their default in the mixin's own frame. - value = parameter.defaultValue || 'initial'; - } + // Missing arguments resolve to their default in the mixin's own frame. + const value = argumentName === undefined ? defaultParameterValue(parameter) : `var(${argumentName})`; - parameterPrivateRule.append(new Declaration({ + parameterPrivateRule.append(helpers.decl({ prop: parameter.name, value, source: atRule.source, @@ -222,66 +375,92 @@ export class MixinExpander { } /** Only `@private` rules that originate from mixins are transpiled here. */ - private transpile(inserted: Array): void { - const privateRules: Array = []; - for (const node of inserted) { - collectMatches(node, IS_PRIVATE_REGEX, privateRules); - } - - for (const privateRule of privateRules) { - const owner = findOwningRule(privateRule); - if (!owner) { - continue; - } - - this.transpiler.registerAndRemovePrivateRules(privateRule, owner); - } - - const declarations: Array = []; - const atRules: Array = []; - for (const node of inserted) { - collectDeclarationsAndAtRules(node, declarations, atRules); - } - - for (const declaration of declarations) { - this.transpiler.transpileDeclaration(declaration); - } + private transpileExpansion(inserted: Array): void { + this.registrations.push(...this.expansionTranspiler.transpile(inserted)); + } - for (const nestedAtRule of atRules) { - this.transpiler.transpileAtRule(nestedAtRule); - } + private transpileContents(contents: Array, siteRule: Rule): void { + const transpiler = this.expansionRules.has(siteRule) ? this.expansionTranspiler : this.authorTranspiler; + this.registrations.push(...transpiler.transpile(contents, { scope: siteRule })); } /** Mixins applied within this mixin are resolved in the context of the arguments above. */ - private expandNested(inserted: Array): void { - const nestedApplies: Array = []; - for (const node of inserted) { + private expandNested(nodes: Array, helpers: Helpers): ExpandResult { + const nestedApplies: Set = new Set(); + for (const node of nodes) { collectMatches(node, IS_APPLY_REGEX, nestedApplies); } + let result: ExpandResult = 'ignored'; + for (const nestedAtRule of nestedApplies) { if (!nestedAtRule.parent) { continue; } - this.expand(nestedAtRule, false); + const nested = this.expand(nestedAtRule, false, helpers); + if (nested === 'bailed') { + result = 'bailed'; + } else if (nested === 'expanded' && result === 'ignored') { + result = 'expanded'; + } } + + return result; } /** Substitutes `@contents` and charges the budget for the duplicated nodes. */ - private replaceContents(nodes: Array, hasContents: boolean, contents: Array): void { + private replaceContents(nodes: Array, hasContents: boolean, contents: Array, siteRule: Rule | null): Array { const contentsRules: Array = []; - for (const node of nodes) { - collectMatches(node, IS_CONTENTS_REGEX, contentsRules); - } + collectContentsRules(nodes, contentsRules); + + const substituted: Array = []; for (const contentsRule of contentsRules) { - const replacement = hasContents ? contents : (contentsRule.nodes || []); + const useFallback = !hasContents; + const replacement = useFallback ? (contentsRule.nodes || []) : contents; this.spendBudget(countNodes(replacement)); - contentsRule.before(replacement.map((child) => child.clone())); + const clones = replacement.map((child) => child.clone()); + + contentsRule.before(clones); contentsRule.remove(); + + this.registerExpansionRules(clones); + + if (!useFallback && siteRule) { + // Passed-in contents are scoped to the apply site. + this.transpileContents(clones, siteRule); + } else { + // A fallback block is authored in the mixin body. Declarations in it are + // part of the mixin scope and may define private properties. + this.transpileExpansion(clones); + } + + substituted.push(...clones); + + // A fallback block is part of the mixin body, so `@contents` rules in it + // are valid and are substituted as well. + if (useFallback) { + substituted.push(...this.replaceContents(clones, hasContents, contents, siteRule)); + } + } + + return substituted; + } + + private registerExpansionRules(nodes: Array): void { + for (const node of nodes) { + if (node.type === 'rule') { + this.expansionRules.add(node); + } + + if (node.type === 'rule' || node.type === 'atrule') { + node.walkRules((rule) => { + this.expansionRules.add(rule); + }); + } } } @@ -298,6 +477,63 @@ function needsWrapper(mixin: Mixin): boolean { return mixin.parameters.length > 0 || hasPrivateRules(mixin.atRule); } +function isInheritKeyword(value: string | undefined): boolean { + return isSingleKeyword(value, IS_INHERIT_KEYWORD_REGEX); +} + +/** + * Whether a CSS-wide keyword resolves to the guaranteed-invalid value. + * + * `initial`, `unset`, `revert` and `revert-layer` do, `inherit` does not. + * https://drafts.csswg.org/css-mixins-1/#arg-cascade + */ +function isGuaranteedInvalidKeyword(value: string | undefined): boolean { + return isSingleKeyword(value, IS_GUARANTEED_INVALID_KEYWORD_REGEX); +} + +/** Whether a value is a single keyword ident, ignoring surrounding whitespace and comments. */ +function isSingleKeyword(value: string | undefined, keyword: RegExp): boolean { + if (value === undefined) { + return false; + } + + const tokens = preludeTokens(value); + + return tokens.length === 1 && isTokenIdent(tokens[0]) && keyword.test(tokens[0][4].value); +} + +/** The value of a parameter that did not receive an argument. */ +function defaultParameterValue(parameter: MixinParameter): string { + if (parameter.defaultValue === undefined) { + return GUARANTEED_INVALID_VALUE; + } + + return isGuaranteedInvalidKeyword(parameter.defaultValue) ? GUARANTEED_INVALID_VALUE : parameter.defaultValue; +} + +/** `@layer` is invalid in a mixin body and its contents are dropped when applied. */ +function cloneMixinBodyNodes(atRule: AtRule): Array { + const out: Array = []; + + for (const node of atRule.nodes || []) { + if (node.type === 'atrule' && IS_LAYER_REGEX.test(node.name)) { + continue; + } + + const clone = node.clone(); + + if (clone.type === 'rule' || clone.type === 'atrule') { + clone.walkAtRules(IS_LAYER_REGEX, (layer) => { + layer.remove(); + }); + } + + out.push(clone); + } + + return out; +} + function countNodes(nodes: Array): number { let count = 0; @@ -321,54 +557,132 @@ function hasPrivateRules(atRule: AtRule): boolean { return result; } -function findOwningRule(node: ChildNode): Rule | false { - let parent: Node | undefined = node.parent; - while (parent) { - if (parent.type === 'rule') { - return parent as Rule; +function hasPrivateRule(nodes: Array): boolean { + for (const node of nodes) { + // Nodes replaced by `@contents` substitution are no longer in the tree. + if (!node.parent) { + continue; } - if (parent.type === 'atrule' && IS_NESTING_GROUP_RULE_REGEX.test((parent as AtRule).name)) { - parent = parent.parent; - continue; + if (node.type === 'atrule' && IS_PRIVATE_REGEX.test(node.name)) { + return true; } - return false; + if ((node.type === 'rule' || node.type === 'atrule') && hasPrivateRule(node.nodes || [])) { + return true; + } } return false; } -function collectMatches(node: ChildNode, name: RegExp, out: Array): void { +/** Every `@contents` rule that is not inside another `@contents` rule. */ +function collectContentsRules(nodes: Array, out: Array): void { + for (const node of nodes) { + if (node.type === 'atrule' && IS_CONTENTS_REGEX.test(node.name)) { + out.push(node); + continue; + } + + if (node.type === 'rule' || node.type === 'atrule') { + collectContentsRules(node.nodes || [], out); + } + } +} + +function collectMatches(node: ChildNode, name: RegExp, out: Set): void { + // Nodes replaced by `@contents` substitution are no longer in the tree. + if (!node.parent) { + return; + } + if (node.type === 'atrule' && name.test(node.name)) { - out.push(node); + out.add(node); } if (node.type === 'rule' || node.type === 'atrule') { node.walkAtRules(name, (atRule) => { - out.push(atRule); + out.add(atRule); }); } } -function collectDeclarationsAndAtRules(node: ChildNode, declarations: Array, atRules: Array): void { - if (node.type === 'decl') { - declarations.push(node); - } else if (node.type === 'atrule') { - atRules.push(node); +function trimSet(set: Set, size: number): void { + if (set.size <= size) { + return; } - if (node.type === 'rule' || node.type === 'atrule') { - node.walk((child) => { - if (child.type === 'decl') { - declarations.push(child); - } else if (child.type === 'atrule') { - atRules.push(child); - } - }); + const values = [...set]; + + for (let i = size; i < values.length; i++) { + set.delete(values[i]); + } +} + +function blockRuleAndAncestors(rule: Rule, blocked: Set): void { + let current: Rule | null = rule; + + while (current) { + blocked.add(current); + current = parentStyleRule(current); + } +} + +function isBlocked(rule: Rule, blocked: Set): boolean { + let current: Rule | null = rule; + + while (current) { + if (blocked.has(current)) { + return true; + } + + current = parentStyleRule(current); + } + + return false; +} + +function collectRuleAndAncestors(rule: Rule, out: Set): void { + let current: Rule | null = rule; + + while (current) { + out.add(current); + current = parentStyleRule(current); } } +function isOutermost(rule: Rule, rules: Set): boolean { + let parent = parentStyleRule(rule); + + while (parent) { + if (rules.has(parent)) { + return false; + } + + parent = parentStyleRule(parent); + } + + return true; +} + +function parentStyleRule(rule: Rule): Rule | null { + let parent = rule.parent; + + while (parent) { + if (parent.type === 'rule') { + return parent; + } + + if (parent.type !== 'atrule' || !IS_NESTING_GROUP_RULE_REGEX.test(parent.name)) { + return null; + } + + parent = parent.parent; + } + + return null; +} + function hasMixinAncestor(atRule: AtRule): boolean { let parent: AtRule['parent'] = atRule.parent; while (parent) { diff --git a/plugins/postcss-mixins/src/processable-apply.ts b/plugins/postcss-mixins/src/processable-apply.ts index 46bb0027b7..11395abb13 100644 --- a/plugins/postcss-mixins/src/processable-apply.ts +++ b/plugins/postcss-mixins/src/processable-apply.ts @@ -1,7 +1,8 @@ -import type { ComponentValue } from '@csstools/css-parser-algorithms'; -import { isFunctionNode, isSimpleBlockNode, isTokenNode, parseCommaSeparatedListOfComponentValues, parseComponentValue, stringify } from '@csstools/css-parser-algorithms'; -import { isTokenIdent, isTokenOpenCurly, tokenize } from '@csstools/css-tokenizer'; -import type { AtRule } from 'postcss'; +import { isFunctionNode, isTokenNode, parseComponentValue, stringify } from '@csstools/css-parser-algorithms'; +import { isTokenIdent } from '@csstools/css-tokenizer'; +import type { AtRule, Rule } from 'postcss'; +import { parseDashedFunctionArguments } from '@csstools/custom-function-parser'; +import { preludeTokens, rawParams } from './utils'; export const IS_APPLY_REGEX = /^apply$/i; @@ -10,20 +11,26 @@ export type ProcessableApply = { arguments: Array, }; -const IS_IMPORTANT_REGEX = /!\s*important/i; +export const IS_NESTING_GROUP_RULE_REGEX = /^(container|layer|media|scope|starting-style|supports)$/i; +const IS_CSS_WIDE_KEYWORD_REGEX = /^(inherit|initial|unset|revert|revert-layer)$/i; +const IS_KEYFRAMES_REGEX = /^keyframes$/i; export function processableApplyRule(atRule: AtRule): false | ProcessableApply { - if (!atRule.params || !atRule.params.includes('--')) { + const styleRule = applySiteRule(atRule); + if (!styleRule) { return false; } - if (!isInStyleRule(atRule)) { + return processableApplyPrelude(atRule); +} + +/** The name and arguments of an `@apply` rule, without checking the applying context. */ +export function processableApplyPrelude(atRule: AtRule): false | ProcessableApply { + if (!atRule.params) { return false; } - const prelude = parseComponentValue(tokenize({ - css: atRule.params, - })); + const prelude = parseComponentValue(preludeTokens(rawParams(atRule))); let name: string; let args: Array = []; @@ -33,12 +40,12 @@ export function processableApplyRule(atRule: AtRule): false | ProcessableApply { } else if (isFunctionNode(prelude)) { name = prelude.getName(); - const parsedArguments = parseArguments(prelude.value); + const parsedArguments = parseDashedFunctionArguments(prelude.value); if (!parsedArguments) { return false; } - args = parsedArguments; + args = parsedArguments.map((argument) => stringify([argument])); } else { return false; } @@ -53,52 +60,55 @@ export function processableApplyRule(atRule: AtRule): false | ProcessableApply { }; } -function parseArguments(componentValues: Array): false | Array { - const rawArguments = parseCommaSeparatedListOfComponentValues(componentValues.flatMap((componentValue) => componentValue.tokens())); +/** + * Whether an argument is a CSS-wide keyword. + * + * Browsers substitute these keywords into the property that uses the parameter, + * while the specification resolves them in the argument phase. + * https://drafts.csswg.org/css-mixins-1/#arg-cascade + */ +export function hasCSSWideKeywordArgument(apply: ProcessableApply): boolean { + return apply.arguments.some(isCSSWideKeyword); +} - // `--foo()` has no arguments. - if (rawArguments.length === 1 && stringify([rawArguments[0]]).trim() === '') { - return []; - } +/** Whether a value is a single CSS-wide keyword ident, ignoring comments and whitespace. */ +function isCSSWideKeyword(value: string): boolean { + const tokens = preludeTokens(value); - const args: Array = []; + return tokens.length === 1 && isTokenIdent(tokens[0]) && IS_CSS_WIDE_KEYWORD_REGEX.test(tokens[0][4].value); +} - for (const rawArgument of rawArguments) { - // A comma-containing value can be passed as a single argument by wrapping it in `{}`. - const argument = (rawArgument.length === 1 && isSimpleBlockNode(rawArgument[0]) && isTokenOpenCurly(rawArgument[0].startToken) - ? stringify([rawArgument[0].value]) - : stringify([rawArgument]) - ).trim(); +/** + * The style rule an `@apply` rule is in, or `null` when the `@apply` is not in a + * style rule or nested group rule. + */ +export function applySiteRule(atRule: AtRule): Rule | null { + let parent = atRule.parent; - if (argument === '') { - return false; + while (parent) { + if (parent.type === 'rule') { + return isKeyframesRule(parent) ? null : parent; } - if (IS_IMPORTANT_REGEX.test(argument)) { - return false; + if (parent.type !== 'atrule' || !IS_NESTING_GROUP_RULE_REGEX.test(parent.name)) { + return null; } - args.push(argument); + parent = parent.parent; } - return args; + return null; } -const IS_SCOPE_REGEX = /^scope$/i; - -function isInStyleRule(atRule: AtRule): boolean { - const parent = atRule.parent; - if (!parent || parent.type === 'root') { - return false; - } - - if (parent.type === 'rule') { - return true; - } +function isKeyframesRule(rule: AtRule['parent']): boolean { + let parent = rule?.parent; + while (parent) { + if (parent.type === 'atrule' && IS_KEYFRAMES_REGEX.test(parent.name)) { + return true; + } - if (parent.type === 'atrule' && IS_SCOPE_REGEX.test(parent.name)) { - return true; + parent = parent.parent; } - return isInStyleRule(parent); + return false; } diff --git a/plugins/postcss-mixins/src/processable-mixin.ts b/plugins/postcss-mixins/src/processable-mixin.ts index 3d0f8271ef..c38fcc1742 100644 --- a/plugins/postcss-mixins/src/processable-mixin.ts +++ b/plugins/postcss-mixins/src/processable-mixin.ts @@ -1,7 +1,8 @@ -import type { ComponentValue } from '@csstools/css-parser-algorithms'; -import { isFunctionNode, isTokenNode, isWhiteSpaceOrCommentNode, parseCommaSeparatedListOfComponentValues, parseComponentValue, stringify } from '@csstools/css-parser-algorithms'; -import { isTokenColon, isTokenIdent, tokenize } from '@csstools/css-tokenizer'; +import { isFunctionNode, isTokenNode, parseComponentValue } from '@csstools/css-parser-algorithms'; +import { isTokenIdent } from '@csstools/css-tokenizer'; import type { AtRule } from 'postcss'; +import { parseFunctionParameters } from '@csstools/custom-function-parser'; +import { preludeTokens, rawParams } from './utils'; export type MixinParameter = { name: string, @@ -13,15 +14,44 @@ export type ProcessableMixin = { parameters: Array, }; -const IS_UNSUPPORTED_CHILD_RULE = /^result$/i; -const IS_IMPORTANT_REGEX = /!\s*important/i; +/** + * The dashed name in a `@mixin` or `@apply` prelude, even when the rule is not + * transpilable. + */ +export function dashedNameFromParams(params: string): string | null { + if (!params) { + return null; + } -export function processableMixinRule(atRule: AtRule): false | ProcessableMixin { + const prelude = parseComponentValue(preludeTokens(params)); + + let name: string; + if (isTokenNode(prelude) && isTokenIdent(prelude.value)) { + // `@mixin --foo;` is equivalent to `@mixin --foo();` + name = prelude.value[4].value; + } else if (isFunctionNode(prelude)) { + name = prelude.getName(); + } else { + return null; + } + + return name.startsWith('--') ? name : null; +} + +/** + * The name of a `@mixin` rule, even when the rule is not transpilable. + */ +export function mixinRuleName(atRule: AtRule): string | null { if (atRule.name.toLowerCase() !== 'mixin') { - return false; + return null; } - if (!atRule.params || !atRule.params.includes('--')) { + return dashedNameFromParams(rawParams(atRule)); +} + +export function processableMixinRule(atRule: AtRule): false | ProcessableMixin { + const name = mixinRuleName(atRule); + if (!name) { return false; } @@ -34,43 +64,23 @@ export function processableMixinRule(atRule: AtRule): false | ProcessableMixin { return false; } - // `@result` was dropped from the specification, mixins with `@result` are ignored. - let hasUnsupportedChildRule = false; - atRule.walk((node) => { - if (node.type === 'atrule' && IS_UNSUPPORTED_CHILD_RULE.test(node.name)) { - hasUnsupportedChildRule = true; - } - }); - - if (hasUnsupportedChildRule) { - return false; - } - - const prelude = parseComponentValue(tokenize({ - css: atRule.params, - })); + const prelude = parseComponentValue(preludeTokens(rawParams(atRule))); - let name: string; let parameters: Array = []; - if (isTokenNode(prelude) && isTokenIdent(prelude.value)) { - // `@mixin --foo;` is equivalent to `@mixin --foo();` - name = prelude.value[4].value; - } else if (isFunctionNode(prelude)) { - name = prelude.getName(); - - const parsedParameters = parseParameters(prelude.value); - if (!parsedParameters) { + if (isFunctionNode(prelude)) { + const parsedParameters = parseFunctionParameters(prelude.value); + if (!parsedParameters || parsedParameters.some((parameter) => { + const type = parameter.getParameterType(); + return !!type && type !== '*'; + })) { return false; } - parameters = parsedParameters; - } else { - return false; - } - - if (!name.startsWith('--')) { - return false; + parameters = parsedParameters.map((parameter) => ({ + name: parameter.getName(), + defaultValue: parameter.getDefaultValue() ?? undefined, + })); } return { @@ -78,68 +88,3 @@ export function processableMixinRule(atRule: AtRule): false | ProcessableMixin { parameters, }; } - -function parseParameters(componentValues: Array): false | Array { - const rawParameters = parseCommaSeparatedListOfComponentValues(componentValues.flatMap((componentValue) => componentValue.tokens())); - - // `--foo()` has no parameters. - if (rawParameters.length === 1 && stringify([rawParameters[0]]).trim() === '') { - return []; - } - - const parameters: Array = []; - const names = new Set(); - - for (const rawParameter of rawParameters) { - let start = 0; - while (start < rawParameter.length && isWhiteSpaceOrCommentNode(rawParameter[start])) { - start++; - } - - const nameNode = rawParameter[start]; - if (!nameNode || !isTokenNode(nameNode) || !isTokenIdent(nameNode.value) || !nameNode.value[4].value.startsWith('--')) { - return false; - } - - const name = nameNode.value[4].value; - if (names.has(name)) { - return false; - } - - names.add(name); - - let defaultValue: string | undefined; - let hasType = false; - - for (let i = start + 1; i < rawParameter.length; i++) { - const componentValue = rawParameter[i]; - - if (isWhiteSpaceOrCommentNode(componentValue)) { - continue; - } - - if (isTokenNode(componentValue) && isTokenColon(componentValue.value)) { - defaultValue = stringify([rawParameter.slice(i + 1)]).trim() || undefined; - break; - } - - hasType = true; - } - - // TODO: support typed arguments - if (hasType) { - return false; - } - - if (defaultValue && IS_IMPORTANT_REGEX.test(defaultValue)) { - return false; - } - - parameters.push({ - name, - defaultValue, - }); - } - - return parameters; -} diff --git a/plugins/postcss-mixins/src/utils.ts b/plugins/postcss-mixins/src/utils.ts new file mode 100644 index 0000000000..f15c95717c --- /dev/null +++ b/plugins/postcss-mixins/src/utils.ts @@ -0,0 +1,28 @@ +import type { AtRule } from 'postcss'; +import type { CSSToken } from '@csstools/css-tokenizer'; +import { isTokenEOF, isTokenWhiteSpaceOrComment, tokenize } from '@csstools/css-tokenizer'; + +/** The prelude of an at-rule as written, with comments. */ +export function rawParams(atRule: AtRule): string { + const raw = atRule.raws.params; + + return raw && raw.value === atRule.params ? raw.raw : atRule.params; +} + +/** The tokens of a prelude, without leading and trailing whitespace and comments. */ +export function preludeTokens(params: string): Array { + const tokens = tokenize({ css: params }).filter((token) => !isTokenEOF(token)); + + let start = 0; + let end = tokens.length; + + while (start < end && isTokenWhiteSpaceOrComment(tokens[start])) { + start++; + } + + while (end > start && isTokenWhiteSpaceOrComment(tokens[end - 1])) { + end--; + } + + return tokens.slice(start, end); +} diff --git a/plugins/postcss-mixins/test/_tape.mjs b/plugins/postcss-mixins/test/_tape.mjs index 63bcfd9bd6..d21d99eaa8 100644 --- a/plugins/postcss-mixins/test/_tape.mjs +++ b/plugins/postcss-mixins/test/_tape.mjs @@ -20,6 +20,15 @@ postcssTape(plugin)({ preserve: true, }, }, + 'generated-names': { + message: 'generated argument names do not collide with author names', + }, + 'generated-names:preserve-true': { + message: 'generated argument names do not collide with author names with { preserve: true }', + options: { + preserve: true, + }, + }, spaces: { message: 'supports spaces and comments around argument lists', }, @@ -65,6 +74,24 @@ postcssTape(plugin)({ preserve: true, }, }, + property: { + message: 'supports @property rules in @private rules', + }, + 'property:preserve-true': { + message: 'supports @property rules in @private rules with { preserve: true }', + options: { + preserve: true, + }, + }, + layer: { + message: 'drops @layer rules from mixin bodies', + }, + 'layer:preserve-true': { + message: 'drops @layer rules from mixin bodies with { preserve: true }', + options: { + preserve: true, + }, + }, invalid: { message: 'ignores invalid mixin invocations', }, diff --git a/plugins/postcss-mixins/test/arguments.css b/plugins/postcss-mixins/test/arguments.css index 8a03e21298..6125b5bd5a 100644 --- a/plugins/postcss-mixins/test/arguments.css +++ b/plugins/postcss-mixins/test/arguments.css @@ -46,3 +46,202 @@ .g { @apply --no-parameter-list; } + +@mixin --trailing-comma(--color,) { + border-color: var(--color); +} + +.h { + @apply --trailing-comma(green); +} + +@mixin --empty-arguments(--color, --background: teal) { + outline-color: var(--color); + background-color: var(--background); +} + +.i { + @apply --empty-arguments(, green); +} + +.j { + @apply --empty-arguments(green, ); +} + +.k { + @apply --empty-arguments(green, ,); +} + +.l { + @apply --empty-arguments(green, blue,); +} + +.m { + @apply --empty-arguments( green , blue ); +} + +@mixin --empty-default(--color:) { + outline-color: var(--color); +} + +.n { + @apply --empty-default; +} + +@mixin --one(--color) { + color: var(--color); +} + +.trailing-comma-single-argument { + @apply --one(red,); +} + +.invalid-important-argument { + @apply --one(red !important); +} + +.invalid-bang-argument { + @apply --one(!); +} + +.invalid-semicolon-argument { + @apply --one(red;); +} + +@mixin --inherit-default(--color: inherit) { + color: var(--color, red); +} + +.inherit-default { + --color: green; + @apply --inherit-default; +} + +@mixin --inherit-default-with-argument(--color: inherit) { + color: var(--color, red); +} + +.inherit-default-with-argument { + --color: green; + @apply --inherit-default-with-argument(blue); +} + +@mixin --inherit-argument(--color) { + color: var(--color, red); +} + +.inherit-argument { + --color: green; + @apply --inherit-argument(inherit); +} + +@mixin --universal-type(--color type(*)) { + color: var(--color); +} + +.universal-type { + @apply --universal-type(green); +} + +@mixin --invalid-default(--color: red !important) { + color: var(--color); +} + +.invalid-default { + @apply --invalid-default; +} + +@mixin --invalid-empty-parameter(--) { + color: red; +} + +.invalid-empty-parameter { + @apply --invalid-empty-parameter; +} + +@mixin --only-trailing-comma(,) { + color: green; +} + +.only-trailing-comma { + @apply --only-trailing-comma; +} + +@mixin --only-trailing-comma-with-spaces( , ) { + color: green; +} + +.only-trailing-comma-with-spaces { + @apply --only-trailing-comma-with-spaces; +} + +@mixin --comment-in-value(--color: /* default */ blue) { + color: var(--color); +} + +.comment-in-value { + @apply --comment-in-value(/* argument */ green); +} + +@mixin --initial-argument(--color) { + color: var(--color, red); +} + +.initial-argument { + --color: green; + @apply --initial-argument(initial); +} + +@mixin --unset-argument(--color) { + color: var(--color, red); +} + +.unset-argument { + --color: green; + @apply --unset-argument(unset); +} + +@mixin --revert-argument(--color) { + color: var(--color, red); +} + +.revert-argument { + --color: green; + @apply --revert-argument(revert); +} + +@mixin --revert-layer-argument(--color) { + color: var(--color, red); +} + +.revert-layer-argument { + --color: green; + @apply --revert-layer-argument(revert-layer); +} + +@mixin --unset-default(--color: unset) { + color: var(--color, red); +} + +.unset-default { + --color: green; + @apply --unset-default; +} + +@mixin --comment-inherit-default(--color: /* comment */ inherit) { + color: var(--color, red); +} + +.comment-inherit-default { + --color: green; + @apply --comment-inherit-default; +} + +@mixin --comment-inherit-argument(--color) { + color: var(--color, red); +} + +.comment-inherit-argument { + --color: green; + @apply --comment-inherit-argument(/* comment */ inherit); +} diff --git a/plugins/postcss-mixins/test/arguments.expect.css b/plugins/postcss-mixins/test/arguments.expect.css index 510291deb9..8170062a03 100644 --- a/plugins/postcss-mixins/test/arguments.expect.css +++ b/plugins/postcss-mixins/test/arguments.expect.css @@ -1,41 +1,235 @@ .a { - --_csstools-p-165tpc7-0--arg-0: green; - --_csstools-p-165tpc7-1--color: var(--_csstools-p-165tpc7-0--arg-0); - color: var(--_csstools-p-165tpc7-1--color); + --_csstools-mix-165tpc7-arg-0: green; + --_csstools-m-165tpc7-0--color: var(--_csstools-mix-165tpc7-arg-0); + color: var(--_csstools-m-165tpc7-0--color); } .b { - --_csstools-p-165tpc7-2--color: blue; - --_csstools-p-165tpc7-2--background: red; - color: var(--_csstools-p-165tpc7-2--color); - background-color: var(--_csstools-p-165tpc7-2--background); + --_csstools-m-165tpc7-1--color: blue; + --_csstools-m-165tpc7-1--background: red; + color: var(--_csstools-m-165tpc7-1--color); + background-color: var(--_csstools-m-165tpc7-1--background); } .c { - --_csstools-p-165tpc7-3--arg-1: red; - --_csstools-p-165tpc7-4--color: var(--_csstools-p-165tpc7-3--arg-1); - --_csstools-p-165tpc7-4--background: red; - color: var(--_csstools-p-165tpc7-4--color); - background-color: var(--_csstools-p-165tpc7-4--background); + --_csstools-mix-165tpc7-arg-1: red; + --_csstools-m-165tpc7-2--color: var(--_csstools-mix-165tpc7-arg-1); + --_csstools-m-165tpc7-2--background: red; + color: var(--_csstools-m-165tpc7-2--color); + background-color: var(--_csstools-m-165tpc7-2--background); } .d { - --_csstools-p-165tpc7-5--color: initial; - outline-color: var(--_csstools-p-165tpc7-5--color, navy); + --_csstools-m-165tpc7-3--color: initial; + outline-color: var(--_csstools-m-165tpc7-3--color, navy); } .e { - --_csstools-p-165tpc7-6--arg-2: green; - --_csstools-p-165tpc7-7--color: var(--_csstools-p-165tpc7-6--arg-2); - outline-color: var(--_csstools-p-165tpc7-7--color, navy); + --_csstools-mix-165tpc7-arg-2: green; + --_csstools-m-165tpc7-4--color: var(--_csstools-mix-165tpc7-arg-2); + outline-color: var(--_csstools-m-165tpc7-4--color, navy); } .f { - --_csstools-p-165tpc7-8--arg-3: color, background; - --_csstools-p-165tpc7-9--list: var(--_csstools-p-165tpc7-8--arg-3); - transition-property: var(--_csstools-p-165tpc7-9--list); + --_csstools-mix-165tpc7-arg-3: color, background; + --_csstools-m-165tpc7-5--list: var(--_csstools-mix-165tpc7-arg-3); + transition-property: var(--_csstools-m-165tpc7-5--list); } .g { border: 1px solid green; } + +.h { + --_csstools-mix-165tpc7-arg-4: green; + --_csstools-m-165tpc7-6--color: var(--_csstools-mix-165tpc7-arg-4); + border-color: var(--_csstools-m-165tpc7-6--color); +} + +.i { + --_csstools-mix-165tpc7-arg-5: ; + --_csstools-mix-165tpc7-arg-6: green; + --_csstools-m-165tpc7-7--color: var(--_csstools-mix-165tpc7-arg-5); + --_csstools-m-165tpc7-7--background: var(--_csstools-mix-165tpc7-arg-6); + outline-color: var(--_csstools-m-165tpc7-7--color); + background-color: var(--_csstools-m-165tpc7-7--background); +} + +.j { + --_csstools-mix-165tpc7-arg-7: green; + --_csstools-m-165tpc7-8--color: var(--_csstools-mix-165tpc7-arg-7); + --_csstools-m-165tpc7-8--background: teal; + outline-color: var(--_csstools-m-165tpc7-8--color); + background-color: var(--_csstools-m-165tpc7-8--background); +} + +.k { + --_csstools-mix-165tpc7-arg-8: green; + --_csstools-mix-165tpc7-arg-9: ; + --_csstools-m-165tpc7-9--color: var(--_csstools-mix-165tpc7-arg-8); + --_csstools-m-165tpc7-9--background: var(--_csstools-mix-165tpc7-arg-9); + outline-color: var(--_csstools-m-165tpc7-9--color); + background-color: var(--_csstools-m-165tpc7-9--background); +} + +.l { + --_csstools-mix-165tpc7-arg-10: green; + --_csstools-mix-165tpc7-arg-11: blue; + --_csstools-m-165tpc7-a--color: var(--_csstools-mix-165tpc7-arg-10); + --_csstools-m-165tpc7-a--background: var(--_csstools-mix-165tpc7-arg-11); + outline-color: var(--_csstools-m-165tpc7-a--color); + background-color: var(--_csstools-m-165tpc7-a--background); +} + +.m { + --_csstools-mix-165tpc7-arg-12: green; + --_csstools-mix-165tpc7-arg-13: blue; + --_csstools-m-165tpc7-b--color: var(--_csstools-mix-165tpc7-arg-12); + --_csstools-m-165tpc7-b--background: var(--_csstools-mix-165tpc7-arg-13); + outline-color: var(--_csstools-m-165tpc7-b--color); + background-color: var(--_csstools-m-165tpc7-b--background); +} + +.n { + --_csstools-m-165tpc7-c--color: ; + outline-color: var(--_csstools-m-165tpc7-c--color); +} + +@mixin --one(--color) { + color: var(--color); +} + +.trailing-comma-single-argument { + --_csstools-mix-165tpc7-arg-14: red; + --_csstools-m-165tpc7-d--color: var(--_csstools-mix-165tpc7-arg-14); + color: var(--_csstools-m-165tpc7-d--color); +} + +.invalid-important-argument { + @apply --one(red !important); +} + +.invalid-bang-argument { + @apply --one(!); +} + +.invalid-semicolon-argument { + @apply --one(red;); +} + +.inherit-default { + --color: green; + --_csstools-mix-165tpc7-arg-15: var(--color); + --_csstools-m-165tpc7-e--color: var(--_csstools-mix-165tpc7-arg-15); + color: var(--_csstools-m-165tpc7-e--color, red); +} + +.inherit-default-with-argument { + --color: green; + --_csstools-mix-165tpc7-arg-16: blue; + --_csstools-m-165tpc7-f--color: var(--_csstools-mix-165tpc7-arg-16); + color: var(--_csstools-m-165tpc7-f--color, red); +} + +@mixin --inherit-argument(--color) { + color: var(--color, red); +} + +.inherit-argument { + --color: green; + @apply --inherit-argument(inherit); +} + +.universal-type { + --_csstools-mix-165tpc7-arg-17: green; + --_csstools-m-165tpc7-g--color: var(--_csstools-mix-165tpc7-arg-17); + color: var(--_csstools-m-165tpc7-g--color); +} + +@mixin --invalid-default(--color: red !important) { + color: var(--color); +} + +.invalid-default { + @apply --invalid-default; +} + +@mixin --invalid-empty-parameter(--) { + color: red; +} + +.invalid-empty-parameter { + @apply --invalid-empty-parameter; +} + +.only-trailing-comma { + color: green; +} + +.only-trailing-comma-with-spaces { + color: green; +} + +.comment-in-value { + --_csstools-mix-165tpc7-arg-18: /* argument */ green; + --_csstools-m-165tpc7-h--color: var(--_csstools-mix-165tpc7-arg-18); + color: var(--_csstools-m-165tpc7-h--color); +} + +@mixin --initial-argument(--color) { + color: var(--color, red); +} + +.initial-argument { + --color: green; + @apply --initial-argument(initial); +} + +@mixin --unset-argument(--color) { + color: var(--color, red); +} + +.unset-argument { + --color: green; + @apply --unset-argument(unset); +} + +@mixin --revert-argument(--color) { + color: var(--color, red); +} + +.revert-argument { + --color: green; + @apply --revert-argument(revert); +} + +@mixin --revert-layer-argument(--color) { + color: var(--color, red); +} + +.revert-layer-argument { + --color: green; + @apply --revert-layer-argument(revert-layer); +} + +.unset-default { + --color: green; + --_csstools-m-165tpc7-i--color: initial; + color: var(--_csstools-m-165tpc7-i--color, red); +} + +.comment-inherit-default { + --color: green; + --_csstools-mix-165tpc7-arg-19: var(--color); + --_csstools-m-165tpc7-j--color: var(--_csstools-mix-165tpc7-arg-19); + color: var(--_csstools-m-165tpc7-j--color, red); +} + +@mixin --comment-inherit-argument(--color) { + color: var(--color, red); +} + +.comment-inherit-argument { + --color: green; + @apply --comment-inherit-argument(/* comment */ inherit); +} diff --git a/plugins/postcss-mixins/test/arguments.preserve-true.expect.css b/plugins/postcss-mixins/test/arguments.preserve-true.expect.css index 012391cd87..d83663422c 100644 --- a/plugins/postcss-mixins/test/arguments.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/arguments.preserve-true.expect.css @@ -3,9 +3,9 @@ } .a { - --_csstools-p-165tpc7-0--arg-0: green; - --_csstools-p-165tpc7-1--color: var(--_csstools-p-165tpc7-0--arg-0); - color: var(--_csstools-p-165tpc7-1--color); + --_csstools-mix-165tpc7-arg-0: green; + --_csstools-m-165tpc7-0--color: var(--_csstools-mix-165tpc7-arg-0); + color: var(--_csstools-m-165tpc7-0--color); @apply --basic(green); } @@ -15,19 +15,19 @@ } .b { - --_csstools-p-165tpc7-2--color: blue; - --_csstools-p-165tpc7-2--background: red; - color: var(--_csstools-p-165tpc7-2--color); - background-color: var(--_csstools-p-165tpc7-2--background); + --_csstools-m-165tpc7-1--color: blue; + --_csstools-m-165tpc7-1--background: red; + color: var(--_csstools-m-165tpc7-1--color); + background-color: var(--_csstools-m-165tpc7-1--background); @apply --defaults; } .c { - --_csstools-p-165tpc7-3--arg-1: red; - --_csstools-p-165tpc7-4--color: var(--_csstools-p-165tpc7-3--arg-1); - --_csstools-p-165tpc7-4--background: red; - color: var(--_csstools-p-165tpc7-4--color); - background-color: var(--_csstools-p-165tpc7-4--background); + --_csstools-mix-165tpc7-arg-1: red; + --_csstools-m-165tpc7-2--color: var(--_csstools-mix-165tpc7-arg-1); + --_csstools-m-165tpc7-2--background: red; + color: var(--_csstools-m-165tpc7-2--color); + background-color: var(--_csstools-m-165tpc7-2--background); @apply --defaults(red); } @@ -36,15 +36,15 @@ } .d { - --_csstools-p-165tpc7-5--color: initial; - outline-color: var(--_csstools-p-165tpc7-5--color, navy); + --_csstools-m-165tpc7-3--color: initial; + outline-color: var(--_csstools-m-165tpc7-3--color, navy); @apply --fallback; } .e { - --_csstools-p-165tpc7-6--arg-2: green; - --_csstools-p-165tpc7-7--color: var(--_csstools-p-165tpc7-6--arg-2); - outline-color: var(--_csstools-p-165tpc7-7--color, navy); + --_csstools-mix-165tpc7-arg-2: green; + --_csstools-m-165tpc7-4--color: var(--_csstools-mix-165tpc7-arg-2); + outline-color: var(--_csstools-m-165tpc7-4--color, navy); @apply --fallback(green); } @@ -53,9 +53,9 @@ } .f { - --_csstools-p-165tpc7-8--arg-3: color, background; - --_csstools-p-165tpc7-9--list: var(--_csstools-p-165tpc7-8--arg-3); - transition-property: var(--_csstools-p-165tpc7-9--list); + --_csstools-mix-165tpc7-arg-3: color, background; + --_csstools-m-165tpc7-5--list: var(--_csstools-mix-165tpc7-arg-3); + transition-property: var(--_csstools-m-165tpc7-5--list); @apply --braces({color, background}); } @@ -67,3 +67,258 @@ border: 1px solid green; @apply --no-parameter-list; } + +@mixin --trailing-comma(--color,) { + border-color: var(--color); +} + +.h { + --_csstools-mix-165tpc7-arg-4: green; + --_csstools-m-165tpc7-6--color: var(--_csstools-mix-165tpc7-arg-4); + border-color: var(--_csstools-m-165tpc7-6--color); + @apply --trailing-comma(green); +} + +@mixin --empty-arguments(--color, --background: teal) { + outline-color: var(--color); + background-color: var(--background); +} + +.i { + --_csstools-mix-165tpc7-arg-5: ; + --_csstools-mix-165tpc7-arg-6: green; + --_csstools-m-165tpc7-7--color: var(--_csstools-mix-165tpc7-arg-5); + --_csstools-m-165tpc7-7--background: var(--_csstools-mix-165tpc7-arg-6); + outline-color: var(--_csstools-m-165tpc7-7--color); + background-color: var(--_csstools-m-165tpc7-7--background); + @apply --empty-arguments(, green); +} + +.j { + --_csstools-mix-165tpc7-arg-7: green; + --_csstools-m-165tpc7-8--color: var(--_csstools-mix-165tpc7-arg-7); + --_csstools-m-165tpc7-8--background: teal; + outline-color: var(--_csstools-m-165tpc7-8--color); + background-color: var(--_csstools-m-165tpc7-8--background); + @apply --empty-arguments(green, ); +} + +.k { + --_csstools-mix-165tpc7-arg-8: green; + --_csstools-mix-165tpc7-arg-9: ; + --_csstools-m-165tpc7-9--color: var(--_csstools-mix-165tpc7-arg-8); + --_csstools-m-165tpc7-9--background: var(--_csstools-mix-165tpc7-arg-9); + outline-color: var(--_csstools-m-165tpc7-9--color); + background-color: var(--_csstools-m-165tpc7-9--background); + @apply --empty-arguments(green, ,); +} + +.l { + --_csstools-mix-165tpc7-arg-10: green; + --_csstools-mix-165tpc7-arg-11: blue; + --_csstools-m-165tpc7-a--color: var(--_csstools-mix-165tpc7-arg-10); + --_csstools-m-165tpc7-a--background: var(--_csstools-mix-165tpc7-arg-11); + outline-color: var(--_csstools-m-165tpc7-a--color); + background-color: var(--_csstools-m-165tpc7-a--background); + @apply --empty-arguments(green, blue,); +} + +.m { + --_csstools-mix-165tpc7-arg-12: green; + --_csstools-mix-165tpc7-arg-13: blue; + --_csstools-m-165tpc7-b--color: var(--_csstools-mix-165tpc7-arg-12); + --_csstools-m-165tpc7-b--background: var(--_csstools-mix-165tpc7-arg-13); + outline-color: var(--_csstools-m-165tpc7-b--color); + background-color: var(--_csstools-m-165tpc7-b--background); + @apply --empty-arguments( green , blue ); +} + +@mixin --empty-default(--color:) { + outline-color: var(--color); +} + +.n { + --_csstools-m-165tpc7-c--color: ; + outline-color: var(--_csstools-m-165tpc7-c--color); + @apply --empty-default; +} + +@mixin --one(--color) { + color: var(--color); +} + +.trailing-comma-single-argument { + --_csstools-mix-165tpc7-arg-14: red; + --_csstools-m-165tpc7-d--color: var(--_csstools-mix-165tpc7-arg-14); + color: var(--_csstools-m-165tpc7-d--color); + @apply --one(red,); +} + +.invalid-important-argument { + @apply --one(red !important); +} + +.invalid-bang-argument { + @apply --one(!); +} + +.invalid-semicolon-argument { + @apply --one(red;); +} + +@mixin --inherit-default(--color: inherit) { + color: var(--color, red); +} + +.inherit-default { + --color: green; + --_csstools-mix-165tpc7-arg-15: var(--color); + --_csstools-m-165tpc7-e--color: var(--_csstools-mix-165tpc7-arg-15); + color: var(--_csstools-m-165tpc7-e--color, red); + @apply --inherit-default; +} + +@mixin --inherit-default-with-argument(--color: inherit) { + color: var(--color, red); +} + +.inherit-default-with-argument { + --color: green; + --_csstools-mix-165tpc7-arg-16: blue; + --_csstools-m-165tpc7-f--color: var(--_csstools-mix-165tpc7-arg-16); + color: var(--_csstools-m-165tpc7-f--color, red); + @apply --inherit-default-with-argument(blue); +} + +@mixin --inherit-argument(--color) { + color: var(--color, red); +} + +.inherit-argument { + --color: green; + @apply --inherit-argument(inherit); +} + +@mixin --universal-type(--color type(*)) { + color: var(--color); +} + +.universal-type { + --_csstools-mix-165tpc7-arg-17: green; + --_csstools-m-165tpc7-g--color: var(--_csstools-mix-165tpc7-arg-17); + color: var(--_csstools-m-165tpc7-g--color); + @apply --universal-type(green); +} + +@mixin --invalid-default(--color: red !important) { + color: var(--color); +} + +.invalid-default { + @apply --invalid-default; +} + +@mixin --invalid-empty-parameter(--) { + color: red; +} + +.invalid-empty-parameter { + @apply --invalid-empty-parameter; +} + +@mixin --only-trailing-comma(,) { + color: green; +} + +.only-trailing-comma { + color: green; + @apply --only-trailing-comma; +} + +@mixin --only-trailing-comma-with-spaces( , ) { + color: green; +} + +.only-trailing-comma-with-spaces { + color: green; + @apply --only-trailing-comma-with-spaces; +} + +@mixin --comment-in-value(--color: /* default */ blue) { + color: var(--color); +} + +.comment-in-value { + --_csstools-mix-165tpc7-arg-18: /* argument */ green; + --_csstools-m-165tpc7-h--color: var(--_csstools-mix-165tpc7-arg-18); + color: var(--_csstools-m-165tpc7-h--color); + @apply --comment-in-value(/* argument */ green); +} + +@mixin --initial-argument(--color) { + color: var(--color, red); +} + +.initial-argument { + --color: green; + @apply --initial-argument(initial); +} + +@mixin --unset-argument(--color) { + color: var(--color, red); +} + +.unset-argument { + --color: green; + @apply --unset-argument(unset); +} + +@mixin --revert-argument(--color) { + color: var(--color, red); +} + +.revert-argument { + --color: green; + @apply --revert-argument(revert); +} + +@mixin --revert-layer-argument(--color) { + color: var(--color, red); +} + +.revert-layer-argument { + --color: green; + @apply --revert-layer-argument(revert-layer); +} + +@mixin --unset-default(--color: unset) { + color: var(--color, red); +} + +.unset-default { + --color: green; + --_csstools-m-165tpc7-i--color: initial; + color: var(--_csstools-m-165tpc7-i--color, red); + @apply --unset-default; +} + +@mixin --comment-inherit-default(--color: /* comment */ inherit) { + color: var(--color, red); +} + +.comment-inherit-default { + --color: green; + --_csstools-mix-165tpc7-arg-19: var(--color); + --_csstools-m-165tpc7-j--color: var(--_csstools-mix-165tpc7-arg-19); + color: var(--_csstools-m-165tpc7-j--color, red); + @apply --comment-inherit-default; +} + +@mixin --comment-inherit-argument(--color) { + color: var(--color, red); +} + +.comment-inherit-argument { + --color: green; + @apply --comment-inherit-argument(/* comment */ inherit); +} diff --git a/plugins/postcss-mixins/test/basic.css b/plugins/postcss-mixins/test/basic.css index 3217680dce..d3a453d6d3 100644 --- a/plugins/postcss-mixins/test/basic.css +++ b/plugins/postcss-mixins/test/basic.css @@ -29,3 +29,11 @@ order: 1; } + +@mixin --\65 scaped() { + color: green; +} + +.escaped-name { + @apply --\65 scaped; +} diff --git a/plugins/postcss-mixins/test/basic.expect.css b/plugins/postcss-mixins/test/basic.expect.css index 73878cce64..00593c13e7 100644 --- a/plugins/postcss-mixins/test/basic.expect.css +++ b/plugins/postcss-mixins/test/basic.expect.css @@ -1,9 +1,13 @@ +@mixin --foo() { + color: green; +} + .foo { color: green; } @scope (.foo) { - color: green; + @apply --foo(); } .bar { @@ -24,3 +28,7 @@ order: 1; } + +.escaped-name { + color: green; +} diff --git a/plugins/postcss-mixins/test/basic.preserve-true.expect.css b/plugins/postcss-mixins/test/basic.preserve-true.expect.css index 3900c04f84..7fa8edc528 100644 --- a/plugins/postcss-mixins/test/basic.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/basic.preserve-true.expect.css @@ -8,7 +8,6 @@ } @scope (.foo) { - color: green; @apply --foo(); } @@ -41,3 +40,12 @@ order: 1; } + +@mixin --\65 scaped() { + color: green; +} + +.escaped-name { + color: green; + @apply --\65 scaped; +} diff --git a/plugins/postcss-mixins/test/contents.css b/plugins/postcss-mixins/test/contents.css index d6ab4193db..7064973c38 100644 --- a/plugins/postcss-mixins/test/contents.css +++ b/plugins/postcss-mixins/test/contents.css @@ -69,3 +69,173 @@ background-color: var(--color); } } + +@mixin --fallback-argument(--color) { + @contents { + color: var(--color); + } +} + +.fallback-argument { + --color: blue; + @apply --fallback-argument(red); +} + +@mixin --contents-inner() { + @contents; +} + +@mixin --contents-outer(--color) { + @apply --contents-inner { + color: var(--color); + } +} + +.contents-outer { + --color: blue; + @apply --contents-outer(red); +} + +@mixin --fallback-private() { + @contents { + @private { + --x: red; + } + color: var(--x); + } +} + +.fallback-private { + @apply --fallback-private; +} + +@mixin --discarded-fallback() { + @contents { + @private { + --x: red; + } + } + color: var(--x); +} + +.discarded-fallback { + --x: green; + @apply --discarded-fallback { + color: blue; + } +} + +@mixin --contents-scope() { + @private { + --size: 20px; + } + @contents; +} + +.contents-scope { + @apply --contents-scope { + width: var(--size, 33px); + } +} + +@mixin --fallback-nested-rule(--color) { + @contents { + & .nested-fallback { + color: var(--color); + } + } +} + +.fallback-nested-rule { + @apply --fallback-nested-rule(red); +} + +@mixin --contents-inner-private() { + @contents; +} + +@mixin --contents-outer-private(--color) { + @apply --contents-inner-private { + @private { + --local: var(--color); + } + color: var(--local); + } +} + +.contents-outer-private { + @apply --contents-outer-private(red); +} + +@mixin --contents-apply-private() { + @contents; +} + +.contents-apply-private { + @private { + --size: 1px; + } + @apply --contents-apply-private { + width: var(--size); + } +} + +@mixin --contents-inner-apply() { + color: green; +} + +@mixin --contents-with-apply() { + @contents; +} + +.contents-with-apply { + @apply --contents-with-apply { + @apply --contents-inner-apply; + } +} + +@mixin --contents-fallback-apply() { + @contents { + @apply --contents-inner-apply; + } +} + +.contents-fallback-apply { + @apply --contents-fallback-apply; +} + +@mixin --nested-contents-fallback() { + @contents { + @contents { + color: green; + } + } +} + +.nested-contents-fallback { + @apply --nested-contents-fallback; +} + +@mixin --unsupported-in-contents(--color ) { + color: var(--color); +} + +@mixin --contents-unsupported() { + @contents; +} + +.contents-unsupported { + @apply --contents-unsupported { + @apply --unsupported-in-contents(green); + } +} + +@mixin --inherit-keyword-in-contents(--color) { + color: var(--color, red); +} + +.contents-inherit-keyword { + @apply --contents-unsupported { + @apply --inherit-keyword-in-contents(inherit); + } +} diff --git a/plugins/postcss-mixins/test/contents.expect.css b/plugins/postcss-mixins/test/contents.expect.css index 5e42d2ef51..9a77e793b1 100644 --- a/plugins/postcss-mixins/test/contents.expect.css +++ b/plugins/postcss-mixins/test/contents.expect.css @@ -34,8 +34,94 @@ } .i { - --_csstools-p-1i0jh25-0--arg-0: green; - --_csstools-p-1i0jh25-1--color: var(--_csstools-p-1i0jh25-0--arg-0); - color: var(--_csstools-p-1i0jh25-1--color); + --_csstools-mix-1i0jh25-arg-0: green; + --_csstools-m-1i0jh25-0--color: var(--_csstools-mix-1i0jh25-arg-0); + color: var(--_csstools-m-1i0jh25-0--color); background-color: var(--color) } + +.fallback-argument { + --color: blue; + --_csstools-mix-1i0jh25-arg-1: red; + --_csstools-m-1i0jh25-1--color: var(--_csstools-mix-1i0jh25-arg-1); + color: var(--_csstools-m-1i0jh25-1--color); +} + +.contents-outer { + --color: blue; + --_csstools-mix-1i0jh25-arg-2: red; + --_csstools-m-1i0jh25-2--color: var(--_csstools-mix-1i0jh25-arg-2); + color: var(--_csstools-m-1i0jh25-2--color); +} + +.fallback-private { + --_csstools-m-1i0jh25-3--x: red; + color: var(--_csstools-m-1i0jh25-3--x); +} + +.discarded-fallback { + --x: green; + color: blue; + color: var(--x) +} + +.contents-scope { + --_csstools-m-1i0jh25-4--size: 20px; + width: var(--size, 33px) +} + +.fallback-nested-rule { + --_csstools-mix-1i0jh25-arg-3: red; + --_csstools-m-1i0jh25-5--color: var(--_csstools-mix-1i0jh25-arg-3); + & .nested-fallback { + color: var(--_csstools-m-1i0jh25-5--color); + } +} + +.contents-outer-private { + --_csstools-mix-1i0jh25-arg-4: red; + --_csstools-m-1i0jh25-6--color: var(--_csstools-mix-1i0jh25-arg-4); + --_csstools-m-1i0jh25-6--local: var(--_csstools-m-1i0jh25-6--color); + color: var(--_csstools-m-1i0jh25-6--local); +} + +.contents-apply-private { + --_csstools-p-1i0jh25-0--size: 1px; + width: var(--_csstools-p-1i0jh25-0--size) +} + +.contents-with-apply { + color: green +} + +.contents-fallback-apply { + color: green; +} + +.nested-contents-fallback { + color: green; +} + +@mixin --unsupported-in-contents(--color ) { + color: var(--color); +} + +@mixin --contents-unsupported() { + @contents; +} + +.contents-unsupported { + @apply --contents-unsupported { + @apply --unsupported-in-contents(green); + } +} + +@mixin --inherit-keyword-in-contents(--color) { + color: var(--color, red); +} + +.contents-inherit-keyword { + @apply --contents-unsupported { + @apply --inherit-keyword-in-contents(inherit); + } +} diff --git a/plugins/postcss-mixins/test/contents.preserve-true.expect.css b/plugins/postcss-mixins/test/contents.preserve-true.expect.css index d9dc5645c6..c626bde7ec 100644 --- a/plugins/postcss-mixins/test/contents.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/contents.preserve-true.expect.css @@ -76,11 +76,209 @@ } .i { - --_csstools-p-1i0jh25-0--arg-0: green; - --_csstools-p-1i0jh25-1--color: var(--_csstools-p-1i0jh25-0--arg-0); - color: var(--_csstools-p-1i0jh25-1--color); + --_csstools-mix-1i0jh25-arg-0: green; + --_csstools-m-1i0jh25-0--color: var(--_csstools-mix-1i0jh25-arg-0); + color: var(--_csstools-m-1i0jh25-0--color); background-color: var(--color); @apply --args-and-contents(green) { background-color: var(--color); } } + +@mixin --fallback-argument(--color) { + @contents { + color: var(--color); + } +} + +.fallback-argument { + --color: blue; + --_csstools-mix-1i0jh25-arg-1: red; + --_csstools-m-1i0jh25-1--color: var(--_csstools-mix-1i0jh25-arg-1); + color: var(--_csstools-m-1i0jh25-1--color); + @apply --fallback-argument(red); +} + +@mixin --contents-inner() { + @contents; +} + +@mixin --contents-outer(--color) { + @apply --contents-inner { + color: var(--color); + } +} + +.contents-outer { + --color: blue; + --_csstools-mix-1i0jh25-arg-2: red; + --_csstools-m-1i0jh25-2--color: var(--_csstools-mix-1i0jh25-arg-2); + color: var(--_csstools-m-1i0jh25-2--color); + @apply --contents-outer(red); +} + +@mixin --fallback-private() { + @contents { + @private { + --x: red; + } + color: var(--x); + } +} + +.fallback-private { + --_csstools-m-1i0jh25-3--x: red; + color: var(--_csstools-m-1i0jh25-3--x); + @apply --fallback-private; +} + +@mixin --discarded-fallback() { + @contents { + @private { + --x: red; + } + } + color: var(--x); +} + +.discarded-fallback { + --x: green; + color: blue; + color: var(--x); + @apply --discarded-fallback { + color: blue; + } +} + +@mixin --contents-scope() { + @private { + --size: 20px; + } + @contents; +} + +.contents-scope { + --_csstools-m-1i0jh25-4--size: 20px; + width: var(--size, 33px); + @apply --contents-scope { + width: var(--size, 33px); + } +} + +@mixin --fallback-nested-rule(--color) { + @contents { + & .nested-fallback { + color: var(--color); + } + } +} + +.fallback-nested-rule { + --_csstools-mix-1i0jh25-arg-3: red; + --_csstools-m-1i0jh25-5--color: var(--_csstools-mix-1i0jh25-arg-3); + & .nested-fallback { + color: var(--_csstools-m-1i0jh25-5--color); + } + @apply --fallback-nested-rule(red); +} + +@mixin --contents-inner-private() { + @contents; +} + +@mixin --contents-outer-private(--color) { + @apply --contents-inner-private { + @private { + --local: var(--color); + } + color: var(--local); + } +} + +.contents-outer-private { + --_csstools-mix-1i0jh25-arg-4: red; + --_csstools-m-1i0jh25-6--color: var(--_csstools-mix-1i0jh25-arg-4); + --_csstools-m-1i0jh25-6--local: var(--_csstools-m-1i0jh25-6--color); + color: var(--_csstools-m-1i0jh25-6--local); + @apply --contents-outer-private(red); +} + +@mixin --contents-apply-private() { + @contents; +} + +.contents-apply-private { + --_csstools-p-1i0jh25-0--size: 1px; + @private { + --size: 1px; + } + width: var(--_csstools-p-1i0jh25-0--size); + @apply --contents-apply-private { + width: var(--size); + } +} + +@mixin --contents-inner-apply() { + color: green; +} + +@mixin --contents-with-apply() { + @contents; +} + +.contents-with-apply { + color: green; + @apply --contents-with-apply { + @apply --contents-inner-apply; + } +} + +@mixin --contents-fallback-apply() { + @contents { + @apply --contents-inner-apply; + } +} + +.contents-fallback-apply { + color: green; + @apply --contents-fallback-apply; +} + +@mixin --nested-contents-fallback() { + @contents { + @contents { + color: green; + } + } +} + +.nested-contents-fallback { + color: green; + @apply --nested-contents-fallback; +} + +@mixin --unsupported-in-contents(--color ) { + color: var(--color); +} + +@mixin --contents-unsupported() { + @contents; +} + +.contents-unsupported { + @apply --unsupported-in-contents(green); + @apply --contents-unsupported { + @apply --unsupported-in-contents(green); + } +} + +@mixin --inherit-keyword-in-contents(--color) { + color: var(--color, red); +} + +.contents-inherit-keyword { + @apply --inherit-keyword-in-contents(inherit); + @apply --contents-unsupported { + @apply --inherit-keyword-in-contents(inherit); + } +} diff --git a/plugins/postcss-mixins/test/examples/example.expect.css b/plugins/postcss-mixins/test/examples/example.expect.css index be1ce98b68..fe19104687 100644 --- a/plugins/postcss-mixins/test/examples/example.expect.css +++ b/plugins/postcss-mixins/test/examples/example.expect.css @@ -3,9 +3,9 @@ } .bar { - --_csstools-p-1gice1e-0--arg-0: 200; - --_csstools-p-1gice1e-1--baz: var(--_csstools-p-1gice1e-0--arg-0); - color: rgb(var(--_csstools-p-1gice1e-1--baz) 127 0); + --_csstools-mix-1gice1e-arg-0: 200; + --_csstools-m-1gice1e-0--baz: var(--_csstools-mix-1gice1e-arg-0); + color: rgb(var(--_csstools-m-1gice1e-0--baz) 127 0); } .c { diff --git a/plugins/postcss-mixins/test/examples/example.preserve-true.expect.css b/plugins/postcss-mixins/test/examples/example.preserve-true.expect.css index 79a9e59080..26e46804ec 100644 --- a/plugins/postcss-mixins/test/examples/example.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/examples/example.preserve-true.expect.css @@ -12,9 +12,9 @@ } .bar { - --_csstools-p-1gice1e-0--arg-0: 200; - --_csstools-p-1gice1e-1--baz: var(--_csstools-p-1gice1e-0--arg-0); - color: rgb(var(--_csstools-p-1gice1e-1--baz) 127 0); + --_csstools-mix-1gice1e-arg-0: 200; + --_csstools-m-1gice1e-0--baz: var(--_csstools-mix-1gice1e-arg-0); + color: rgb(var(--_csstools-m-1gice1e-0--baz) 127 0); @apply --bar(200); } diff --git a/plugins/postcss-mixins/test/generated-names.css b/plugins/postcss-mixins/test/generated-names.css new file mode 100644 index 0000000000..728e9f41a9 --- /dev/null +++ b/plugins/postcss-mixins/test/generated-names.css @@ -0,0 +1,19 @@ +@mixin --parameter-named-arg-0(--arg-0) { + color: var(--arg-0); +} + +.parameter-named-arg-0 { + @apply --parameter-named-arg-0(green); +} + +@mixin --private-named-arg-1(--arg-1) { + @private { + --arg-1: red; + } + + color: var(--arg-1); +} + +.private-named-arg-1 { + @apply --private-named-arg-1(green); +} diff --git a/plugins/postcss-mixins/test/generated-names.expect.css b/plugins/postcss-mixins/test/generated-names.expect.css new file mode 100644 index 0000000000..23bf714fac --- /dev/null +++ b/plugins/postcss-mixins/test/generated-names.expect.css @@ -0,0 +1,13 @@ +.parameter-named-arg-0 { + --_csstools-mix-c2504z-arg-0: green; + --_csstools-m-c2504z-0--arg-0: var(--_csstools-mix-c2504z-arg-0); + color: var(--_csstools-m-c2504z-0--arg-0); +} + +.private-named-arg-1 { + --_csstools-mix-c2504z-arg-1: green; + --_csstools-m-c2504z-1--arg-1: var(--_csstools-mix-c2504z-arg-1); + --_csstools-m-c2504z-1--arg-1: red; + + color: var(--_csstools-m-c2504z-1--arg-1); +} diff --git a/plugins/postcss-mixins/test/generated-names.preserve-true.expect.css b/plugins/postcss-mixins/test/generated-names.preserve-true.expect.css new file mode 100644 index 0000000000..9fa87c5d0b --- /dev/null +++ b/plugins/postcss-mixins/test/generated-names.preserve-true.expect.css @@ -0,0 +1,27 @@ +@mixin --parameter-named-arg-0(--arg-0) { + color: var(--arg-0); +} + +.parameter-named-arg-0 { + --_csstools-mix-c2504z-arg-0: green; + --_csstools-m-c2504z-0--arg-0: var(--_csstools-mix-c2504z-arg-0); + color: var(--_csstools-m-c2504z-0--arg-0); + @apply --parameter-named-arg-0(green); +} + +@mixin --private-named-arg-1(--arg-1) { + @private { + --arg-1: red; + } + + color: var(--arg-1); +} + +.private-named-arg-1 { + --_csstools-mix-c2504z-arg-1: green; + --_csstools-m-c2504z-1--arg-1: var(--_csstools-mix-c2504z-arg-1); + --_csstools-m-c2504z-1--arg-1: red; + + color: var(--_csstools-m-c2504z-1--arg-1); + @apply --private-named-arg-1(green); +} diff --git a/plugins/postcss-mixins/test/ignore.css b/plugins/postcss-mixins/test/ignore.css index 5f98dd28f4..edb917ef83 100644 --- a/plugins/postcss-mixins/test/ignore.css +++ b/plugins/postcss-mixins/test/ignore.css @@ -10,16 +10,6 @@ @apply --ignore-a; } -@mixin --ignore-b { - @result { - color: green; - } -} - -.ignore-b { - @apply --ignore-b; -} - @media screen { @mixin --ignore-c { color: red; @@ -62,10 +52,16 @@ @apply --ignore-i; } -@mixin --ignore-j(--color,) { - color: var(--color); +@mixin --ignore-k() { + color: red; +} + +@media screen { + @mixin --ignore-l() { + @apply --ignore-k; + } } -.ignore-j { - @apply --ignore-j(red); +.ignore-l { + @apply --ignore-l; } diff --git a/plugins/postcss-mixins/test/invalid.css b/plugins/postcss-mixins/test/invalid.css index fd1327cf63..93122c65a3 100644 --- a/plugins/postcss-mixins/test/invalid.css +++ b/plugins/postcss-mixins/test/invalid.css @@ -10,10 +10,6 @@ @apply --one(red !important); } -.trailing-empty-argument { - @apply --one(red,); -} - .leading-empty-argument { @apply --one(,red); } diff --git a/plugins/postcss-mixins/test/invalid.expect.css b/plugins/postcss-mixins/test/invalid.expect.css index d5d99732c0..93122c65a3 100644 --- a/plugins/postcss-mixins/test/invalid.expect.css +++ b/plugins/postcss-mixins/test/invalid.expect.css @@ -1,3 +1,7 @@ +@mixin --one(--color) { + color: var(--color); +} + .too-many-arguments { @apply --one(green, blue); } @@ -6,10 +10,6 @@ @apply --one(red !important); } -.trailing-empty-argument { - @apply --one(red,); -} - .leading-empty-argument { @apply --one(,red); } @@ -18,6 +18,10 @@ @apply --one(red,,blue); } +@mixin --defined() { + color: green; +} + @apply --defined; @media screen { diff --git a/plugins/postcss-mixins/test/invalid.preserve-true.expect.css b/plugins/postcss-mixins/test/invalid.preserve-true.expect.css index fd1327cf63..93122c65a3 100644 --- a/plugins/postcss-mixins/test/invalid.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/invalid.preserve-true.expect.css @@ -10,10 +10,6 @@ @apply --one(red !important); } -.trailing-empty-argument { - @apply --one(red,); -} - .leading-empty-argument { @apply --one(,red); } diff --git a/plugins/postcss-mixins/test/layer.css b/plugins/postcss-mixins/test/layer.css new file mode 100644 index 0000000000..d208905c28 --- /dev/null +++ b/plugins/postcss-mixins/test/layer.css @@ -0,0 +1,35 @@ +@mixin --with-layer() { + @layer one { + color: red; + } + + @layer two { + @layer three { + color: orange; + } + } + + @media (min-width: 1px) { + @layer four { + color: yellow; + } + + color: green; + } + + color: blue; +} + +.layer { + @apply --with-layer; +} + +@mixin --only-layer() { + @layer one { + color: red; + } +} + +.only-layer { + @apply --only-layer; +} diff --git a/plugins/postcss-mixins/test/layer.expect.css b/plugins/postcss-mixins/test/layer.expect.css new file mode 100644 index 0000000000..d2d1a4da75 --- /dev/null +++ b/plugins/postcss-mixins/test/layer.expect.css @@ -0,0 +1,12 @@ +.layer { + + @media (min-width: 1px) { + + color: green; + } + + color: blue; +} + +.only-layer { +} diff --git a/plugins/postcss-mixins/test/layer.preserve-true.expect.css b/plugins/postcss-mixins/test/layer.preserve-true.expect.css new file mode 100644 index 0000000000..fe6f1b78f6 --- /dev/null +++ b/plugins/postcss-mixins/test/layer.preserve-true.expect.css @@ -0,0 +1,42 @@ +@mixin --with-layer() { + @layer one { + color: red; + } + + @layer two { + @layer three { + color: orange; + } + } + + @media (min-width: 1px) { + @layer four { + color: yellow; + } + + color: green; + } + + color: blue; +} + +.layer { + + @media (min-width: 1px) { + + color: green; + } + + color: blue; + @apply --with-layer; +} + +@mixin --only-layer() { + @layer one { + color: red; + } +} + +.only-layer { + @apply --only-layer; +} diff --git a/plugins/postcss-mixins/test/nested-mixins.css b/plugins/postcss-mixins/test/nested-mixins.css index e407432238..da543b0a15 100644 --- a/plugins/postcss-mixins/test/nested-mixins.css +++ b/plugins/postcss-mixins/test/nested-mixins.css @@ -47,3 +47,32 @@ .d { @apply --cycle-a; } + +@mixin --nested-argument-inner() { + color: var(--color); +} + +@mixin --nested-argument-outer(--color) { + @apply --nested-argument-inner; +} + +.nested-argument { + --color: blue; + @apply --nested-argument-outer(red); +} + +@mixin --nested-private-inner() { + color: var(--x); +} + +@mixin --nested-private-outer() { + @private { + --x: red; + } + @apply --nested-private-inner; +} + +.nested-private { + --color: blue; + @apply --nested-private-outer; +} diff --git a/plugins/postcss-mixins/test/nested-mixins.expect.css b/plugins/postcss-mixins/test/nested-mixins.expect.css index 6c662c96eb..80fe27e73e 100644 --- a/plugins/postcss-mixins/test/nested-mixins.expect.css +++ b/plugins/postcss-mixins/test/nested-mixins.expect.css @@ -4,22 +4,43 @@ } .b { - --_csstools-p-1rmdrz7-0--arg-0: red; - --_csstools-p-1rmdrz7-1--outer-color: var(--_csstools-p-1rmdrz7-0--arg-0); - --_csstools-p-1rmdrz7-2--arg-1: var(--_csstools-p-1rmdrz7-1--outer-color); - --_csstools-p-1rmdrz7-3--inner-color: var(--_csstools-p-1rmdrz7-2--arg-1); - border-color: var(--_csstools-p-1rmdrz7-3--inner-color); + --_csstools-mix-1rmdrz7-arg-0: red; + --_csstools-m-1rmdrz7-0--outer-color: var(--_csstools-mix-1rmdrz7-arg-0); + --_csstools-mix-1rmdrz7-arg-1: var(--_csstools-m-1rmdrz7-0--outer-color); + --_csstools-m-1rmdrz7-1--inner-color: var(--_csstools-mix-1rmdrz7-arg-1); + border-color: var(--_csstools-m-1rmdrz7-1--inner-color); } .c { - --_csstools-p-1rmdrz7-4--arg-2: red; - --_csstools-p-1rmdrz7-5--color: var(--_csstools-p-1rmdrz7-4--arg-2); - --_csstools-p-1rmdrz7-6--arg-3: blue; - --_csstools-p-1rmdrz7-7--color: var(--_csstools-p-1rmdrz7-6--arg-3); - border-color: var(--_csstools-p-1rmdrz7-7--color); - color: var(--_csstools-p-1rmdrz7-5--color); + --_csstools-mix-1rmdrz7-arg-2: red; + --_csstools-m-1rmdrz7-2--color: var(--_csstools-mix-1rmdrz7-arg-2); + --_csstools-mix-1rmdrz7-arg-3: blue; + --_csstools-m-1rmdrz7-3--color: var(--_csstools-mix-1rmdrz7-arg-3); + border-color: var(--_csstools-m-1rmdrz7-3--color); + color: var(--_csstools-m-1rmdrz7-2--color); +} + +@mixin --cycle-a() { + @apply --cycle-b; +} + +@mixin --cycle-b() { + @apply --cycle-a; } .d { @apply --cycle-a; } + +.nested-argument { + --color: blue; + --_csstools-mix-1rmdrz7-arg-4: red; + --_csstools-m-1rmdrz7-4--color: var(--_csstools-mix-1rmdrz7-arg-4); + color: var(--_csstools-m-1rmdrz7-4--color); +} + +.nested-private { + --color: blue; + --_csstools-m-1rmdrz7-5--x: red; + color: var(--_csstools-m-1rmdrz7-5--x); +} diff --git a/plugins/postcss-mixins/test/nested-mixins.preserve-true.expect.css b/plugins/postcss-mixins/test/nested-mixins.preserve-true.expect.css index f417dceb0c..ce384caefb 100644 --- a/plugins/postcss-mixins/test/nested-mixins.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/nested-mixins.preserve-true.expect.css @@ -22,11 +22,11 @@ } .b { - --_csstools-p-1rmdrz7-0--arg-0: red; - --_csstools-p-1rmdrz7-1--outer-color: var(--_csstools-p-1rmdrz7-0--arg-0); - --_csstools-p-1rmdrz7-2--arg-1: var(--_csstools-p-1rmdrz7-1--outer-color); - --_csstools-p-1rmdrz7-3--inner-color: var(--_csstools-p-1rmdrz7-2--arg-1); - border-color: var(--_csstools-p-1rmdrz7-3--inner-color); + --_csstools-mix-1rmdrz7-arg-0: red; + --_csstools-m-1rmdrz7-0--outer-color: var(--_csstools-mix-1rmdrz7-arg-0); + --_csstools-mix-1rmdrz7-arg-1: var(--_csstools-m-1rmdrz7-0--outer-color); + --_csstools-m-1rmdrz7-1--inner-color: var(--_csstools-mix-1rmdrz7-arg-1); + border-color: var(--_csstools-m-1rmdrz7-1--inner-color); @apply --outer-args(red); } @@ -40,12 +40,12 @@ } .c { - --_csstools-p-1rmdrz7-4--arg-2: red; - --_csstools-p-1rmdrz7-5--color: var(--_csstools-p-1rmdrz7-4--arg-2); - --_csstools-p-1rmdrz7-6--arg-3: blue; - --_csstools-p-1rmdrz7-7--color: var(--_csstools-p-1rmdrz7-6--arg-3); - border-color: var(--_csstools-p-1rmdrz7-7--color); - color: var(--_csstools-p-1rmdrz7-5--color); + --_csstools-mix-1rmdrz7-arg-2: red; + --_csstools-m-1rmdrz7-2--color: var(--_csstools-mix-1rmdrz7-arg-2); + --_csstools-mix-1rmdrz7-arg-3: blue; + --_csstools-m-1rmdrz7-3--color: var(--_csstools-mix-1rmdrz7-arg-3); + border-color: var(--_csstools-m-1rmdrz7-3--color); + color: var(--_csstools-m-1rmdrz7-2--color); @apply --shadow-outer(red); } @@ -59,5 +59,38 @@ .d { @apply --cycle-a; - @apply --cycle-a; +} + +@mixin --nested-argument-inner() { + color: var(--color); +} + +@mixin --nested-argument-outer(--color) { + @apply --nested-argument-inner; +} + +.nested-argument { + --color: blue; + --_csstools-mix-1rmdrz7-arg-4: red; + --_csstools-m-1rmdrz7-4--color: var(--_csstools-mix-1rmdrz7-arg-4); + color: var(--_csstools-m-1rmdrz7-4--color); + @apply --nested-argument-outer(red); +} + +@mixin --nested-private-inner() { + color: var(--x); +} + +@mixin --nested-private-outer() { + @private { + --x: red; + } + @apply --nested-private-inner; +} + +.nested-private { + --color: blue; + --_csstools-m-1rmdrz7-5--x: red; + color: var(--_csstools-m-1rmdrz7-5--x); + @apply --nested-private-outer; } diff --git a/plugins/postcss-mixins/test/nesting.expect.css b/plugins/postcss-mixins/test/nesting.expect.css index 99242775e4..24b87d3338 100644 --- a/plugins/postcss-mixins/test/nesting.expect.css +++ b/plugins/postcss-mixins/test/nesting.expect.css @@ -13,10 +13,10 @@ } .b { - --_csstools-p-1sa7v3t-0--arg-0: red; - --_csstools-p-1sa7v3t-1--color: var(--_csstools-p-1sa7v3t-0--arg-0); + --_csstools-mix-1sa7v3t-arg-0: red; + --_csstools-m-1sa7v3t-0--color: var(--_csstools-mix-1sa7v3t-arg-0); & { - color: var(--_csstools-p-1sa7v3t-1--color); + color: var(--_csstools-m-1sa7v3t-0--color); } } diff --git a/plugins/postcss-mixins/test/nesting.preserve-true.expect.css b/plugins/postcss-mixins/test/nesting.preserve-true.expect.css index 5b0c5566ba..7a098789ee 100644 --- a/plugins/postcss-mixins/test/nesting.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/nesting.preserve-true.expect.css @@ -28,10 +28,10 @@ } .b { - --_csstools-p-1sa7v3t-0--arg-0: red; - --_csstools-p-1sa7v3t-1--color: var(--_csstools-p-1sa7v3t-0--arg-0); + --_csstools-mix-1sa7v3t-arg-0: red; + --_csstools-m-1sa7v3t-0--color: var(--_csstools-mix-1sa7v3t-arg-0); & { - color: var(--_csstools-p-1sa7v3t-1--color); + color: var(--_csstools-m-1sa7v3t-0--color); } @apply --author-nesting-with-args(red); } diff --git a/plugins/postcss-mixins/test/private.css b/plugins/postcss-mixins/test/private.css index e3d299342c..c2d9505b16 100644 --- a/plugins/postcss-mixins/test/private.css +++ b/plugins/postcss-mixins/test/private.css @@ -21,3 +21,40 @@ .b { @apply --args-and-private(red); } + +@mixin --inner-private() { + @private { + --x: 1px; + } + + width: var(--x); +} + +@mixin --outer-private() { + @private { + --y: 2px; + } + + @apply --inner-private; + height: var(--y); +} + +.nested-private { + @apply --outer-private; +} + +@function --function-local() { + --value: var(--applying-private-color); + result: var(--value); +} + +@mixin --applying-private() { + color: var(--applying-private-color); +} + +.applying-private { + @private { + --applying-private-color: green; + } + @apply --applying-private; +} diff --git a/plugins/postcss-mixins/test/private.expect.css b/plugins/postcss-mixins/test/private.expect.css index 0f1abefbc9..67939c748c 100644 --- a/plugins/postcss-mixins/test/private.expect.css +++ b/plugins/postcss-mixins/test/private.expect.css @@ -1,11 +1,31 @@ .a { - --_csstools-p-pjvzd8-0--shadow: 2px 2px black; - box-shadow: var(--_csstools-p-pjvzd8-0--shadow); + --_csstools-m-pjvzd8-0--shadow: 2px 2px black; + + box-shadow: var(--_csstools-m-pjvzd8-0--shadow); } .b { - --_csstools-p-pjvzd8-1--arg-0: red; - --_csstools-p-pjvzd8-2--color: var(--_csstools-p-pjvzd8-1--arg-0); - --_csstools-p-pjvzd8-2--local: var(--_csstools-p-pjvzd8-2--color); - color: var(--_csstools-p-pjvzd8-2--local); + --_csstools-mix-pjvzd8-arg-0: red; + --_csstools-m-pjvzd8-1--color: var(--_csstools-mix-pjvzd8-arg-0); + --_csstools-m-pjvzd8-1--local: var(--_csstools-m-pjvzd8-1--color); + + color: var(--_csstools-m-pjvzd8-1--local); +} + +.nested-private { + --_csstools-m-pjvzd8-2--y: 2px; + --_csstools-m-pjvzd8-3--x: 1px; + + width: var(--_csstools-m-pjvzd8-3--x); + height: var(--_csstools-m-pjvzd8-2--y); +} + +@function --function-local() { + --value: var(--applying-private-color); + result: var(--value); +} + +.applying-private { + --_csstools-p-pjvzd8-0--applying-private-color: green; + color: var(--_csstools-p-pjvzd8-0--applying-private-color); } diff --git a/plugins/postcss-mixins/test/private.preserve-true.expect.css b/plugins/postcss-mixins/test/private.preserve-true.expect.css index fc8467667a..37cd073b81 100644 --- a/plugins/postcss-mixins/test/private.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/private.preserve-true.expect.css @@ -7,8 +7,9 @@ } .a { - --_csstools-p-pjvzd8-0--shadow: 2px 2px black; - box-shadow: var(--_csstools-p-pjvzd8-0--shadow); + --_csstools-m-pjvzd8-0--shadow: 2px 2px black; + + box-shadow: var(--_csstools-m-pjvzd8-0--shadow); @apply --with-private; } @@ -21,9 +22,54 @@ } .b { - --_csstools-p-pjvzd8-1--arg-0: red; - --_csstools-p-pjvzd8-2--color: var(--_csstools-p-pjvzd8-1--arg-0); - --_csstools-p-pjvzd8-2--local: var(--_csstools-p-pjvzd8-2--color); - color: var(--_csstools-p-pjvzd8-2--local); + --_csstools-mix-pjvzd8-arg-0: red; + --_csstools-m-pjvzd8-1--color: var(--_csstools-mix-pjvzd8-arg-0); + --_csstools-m-pjvzd8-1--local: var(--_csstools-m-pjvzd8-1--color); + + color: var(--_csstools-m-pjvzd8-1--local); @apply --args-and-private(red); } + +@mixin --inner-private() { + @private { + --x: 1px; + } + + width: var(--x); +} + +@mixin --outer-private() { + @private { + --y: 2px; + } + + @apply --inner-private; + height: var(--y); +} + +.nested-private { + --_csstools-m-pjvzd8-2--y: 2px; + --_csstools-m-pjvzd8-3--x: 1px; + + width: var(--_csstools-m-pjvzd8-3--x); + height: var(--_csstools-m-pjvzd8-2--y); + @apply --outer-private; +} + +@function --function-local() { + --value: var(--applying-private-color); + result: var(--value); +} + +@mixin --applying-private() { + color: var(--applying-private-color); +} + +.applying-private { + --_csstools-p-pjvzd8-0--applying-private-color: green; + @private { + --applying-private-color: green; + } + color: var(--_csstools-p-pjvzd8-0--applying-private-color); + @apply --applying-private; +} diff --git a/plugins/postcss-mixins/test/property.css b/plugins/postcss-mixins/test/property.css new file mode 100644 index 0000000000..2c8acf74f2 --- /dev/null +++ b/plugins/postcss-mixins/test/property.css @@ -0,0 +1,148 @@ +@mixin --registered-private() { + @private { + @property --size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --size-a, --size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --size-c : 12px; + + @property --size-d type(#): red, blue; + + @property --size-e : red; + + --size: 20px; + --size-a: 30px; + --size-b: 40px; + --size-c: 40px; + --size-d: red, blue; + --size-e: blue; + } + + @private { + @property --initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --initial-untyped: 6px; + } + + width: var(--size); + min-width: var(--initial-size); + height: var(--size-a); + min-height: var(--size-b); + max-height: var(--size-c); + max-width: var(--size-d); + inline-size: var(--size-e); + border-width: var(--initial-untyped); +} + +.registered-private-a { + @apply --registered-private; +} + +.registered-private-b { + @apply --registered-private; +} + +@mixin --escaped-private() { + @private { + @property --\66 oo : 20px; + --\66 oo: 30px; + } + + width: var(--\66 oo); +} + +.escaped-private { + @apply --escaped-private; +} + +@mixin --container-registered() { + @container (width > 10px) { + @private { + @property --container-size : 10px; + --container-size: 20px; + } + } + + width: var(--container-size); +} + +.container-registered { + @apply --container-registered; +} + +@mixin --starting-style-registered() { + @starting-style { + @private { + @property --starting-size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + } + } + + width: var(--starting-size); +} + +.starting-style-registered { + @apply --starting-style-registered; +} + +@mixin --media-registered() { + @private { + @property --media-size : 1em; + --media-size: 2em; + } + + width: var(--media-size); +} + +@media (min-width: 1px) { + .media-registered { + @apply --media-registered; + } +} + +@layer outer { + .layer-registered { + @apply --media-registered; + } +} + +@mixin --anonymous-layer-registered() { + @private { + @property --anonymous-layer-size : 10px; + --anonymous-layer-size: 20px; + } + + width: var(--anonymous-layer-size); +} + +@layer { + .anonymous-layer-registered { + @apply --anonymous-layer-registered; + } +} + +@mixin --plain-after-bail() { + color: green; +} + +@layer { + .anonymous-layer-with-sibling { + @apply --plain-after-bail; + @apply --anonymous-layer-registered; + } +} diff --git a/plugins/postcss-mixins/test/property.expect.css b/plugins/postcss-mixins/test/property.expect.css new file mode 100644 index 0000000000..680fcee0df --- /dev/null +++ b/plugins/postcss-mixins/test/property.expect.css @@ -0,0 +1,161 @@ +.registered-private-a { + + --_csstools-m-7q9ama-0--size: 20px; + --_csstools-m-7q9ama-0--size-a: 30px; + --_csstools-m-7q9ama-0--size-b: 40px; + --_csstools-m-7q9ama-0--size-c: 40px; + --_csstools-m-7q9ama-0--size-d: red, blue; + --_csstools-m-7q9ama-0--size-e: blue; + + width: var(--_csstools-m-7q9ama-0--size); + min-width: var(--_csstools-m-7q9ama-0--initial-size); + height: var(--_csstools-m-7q9ama-0--size-a); + min-height: var(--_csstools-m-7q9ama-0--size-b); + max-height: var(--_csstools-m-7q9ama-0--size-c); + max-width: var(--_csstools-m-7q9ama-0--size-d); + inline-size: var(--_csstools-m-7q9ama-0--size-e); + border-width: var(--_csstools-m-7q9ama-0--initial-untyped); +} + +.registered-private-b { + + --_csstools-m-7q9ama-1--size: 20px; + --_csstools-m-7q9ama-1--size-a: 30px; + --_csstools-m-7q9ama-1--size-b: 40px; + --_csstools-m-7q9ama-1--size-c: 40px; + --_csstools-m-7q9ama-1--size-d: red, blue; + --_csstools-m-7q9ama-1--size-e: blue; + + width: var(--_csstools-m-7q9ama-1--size); + min-width: var(--_csstools-m-7q9ama-1--initial-size); + height: var(--_csstools-m-7q9ama-1--size-a); + min-height: var(--_csstools-m-7q9ama-1--size-b); + max-height: var(--_csstools-m-7q9ama-1--size-c); + max-width: var(--_csstools-m-7q9ama-1--size-d); + inline-size: var(--_csstools-m-7q9ama-1--size-e); + border-width: var(--_csstools-m-7q9ama-1--initial-untyped); +} + +.escaped-private { + --_csstools-m-7q9ama-2--\66 oo: 30px; + + width: var(--_csstools-m-7q9ama-2--foo); +} + +.container-registered { + @container (width > 10px) { + --_csstools-m-7q9ama-3--container-size: 20px + } + + width: var(--_csstools-m-7q9ama-3--container-size); +} + +.starting-style-registered { + + width: var(--_csstools-m-7q9ama-4--starting-size); +} + +@media (min-width: 1px) { + .media-registered { + --_csstools-m-7q9ama-5--media-size: 2em; + + width: var(--_csstools-m-7q9ama-5--media-size); + } +} + +@layer outer { + .layer-registered { + --_csstools-m-7q9ama-6--media-size: 2em; + + width: var(--_csstools-m-7q9ama-6--media-size); + } +} + +@mixin --anonymous-layer-registered() { + @private { + @property --anonymous-layer-size : 10px; + --anonymous-layer-size: 20px; + } + + width: var(--anonymous-layer-size); +} + +@layer { + .anonymous-layer-registered { + @apply --anonymous-layer-registered; + } +} + +@mixin --plain-after-bail() { + color: green; +} + +@layer { + .anonymous-layer-with-sibling { + @apply --plain-after-bail; + @apply --anonymous-layer-registered; + } +} + @property --_csstools-m-7q9ama-0--size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --_csstools-m-7q9ama-0--size-a, --_csstools-m-7q9ama-0--size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --_csstools-m-7q9ama-0--size-c : 12px; + + @property --_csstools-m-7q9ama-0--size-d type(#): red, blue; + + @property --_csstools-m-7q9ama-0--size-e : red; + @property --_csstools-m-7q9ama-0--initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --_csstools-m-7q9ama-0--initial-untyped: 6px; + @property --_csstools-m-7q9ama-1--size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --_csstools-m-7q9ama-1--size-a, --_csstools-m-7q9ama-1--size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --_csstools-m-7q9ama-1--size-c : 12px; + + @property --_csstools-m-7q9ama-1--size-d type(#): red, blue; + + @property --_csstools-m-7q9ama-1--size-e : red; + @property --_csstools-m-7q9ama-1--initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --_csstools-m-7q9ama-1--initial-untyped: 6px; + @property --_csstools-m-7q9ama-2--foo : 20px; + @property --_csstools-m-7q9ama-3--container-size : 10px; + @property --_csstools-m-7q9ama-4--starting-size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + +@media (min-width: 1px) { + @property --_csstools-m-7q9ama-5--media-size : 1em +} + +@layer outer { + @property --_csstools-m-7q9ama-6--media-size : 1em +} diff --git a/plugins/postcss-mixins/test/property.preserve-true.expect.css b/plugins/postcss-mixins/test/property.preserve-true.expect.css new file mode 100644 index 0000000000..9344fce570 --- /dev/null +++ b/plugins/postcss-mixins/test/property.preserve-true.expect.css @@ -0,0 +1,272 @@ +@mixin --registered-private() { + @private { + @property --size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --size-a, --size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --size-c : 12px; + + @property --size-d type(#): red, blue; + + @property --size-e : red; + + --size: 20px; + --size-a: 30px; + --size-b: 40px; + --size-c: 40px; + --size-d: red, blue; + --size-e: blue; + } + + @private { + @property --initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --initial-untyped: 6px; + } + + width: var(--size); + min-width: var(--initial-size); + height: var(--size-a); + min-height: var(--size-b); + max-height: var(--size-c); + max-width: var(--size-d); + inline-size: var(--size-e); + border-width: var(--initial-untyped); +} + +.registered-private-a { + + --_csstools-m-7q9ama-0--size: 20px; + --_csstools-m-7q9ama-0--size-a: 30px; + --_csstools-m-7q9ama-0--size-b: 40px; + --_csstools-m-7q9ama-0--size-c: 40px; + --_csstools-m-7q9ama-0--size-d: red, blue; + --_csstools-m-7q9ama-0--size-e: blue; + + width: var(--_csstools-m-7q9ama-0--size); + min-width: var(--_csstools-m-7q9ama-0--initial-size); + height: var(--_csstools-m-7q9ama-0--size-a); + min-height: var(--_csstools-m-7q9ama-0--size-b); + max-height: var(--_csstools-m-7q9ama-0--size-c); + max-width: var(--_csstools-m-7q9ama-0--size-d); + inline-size: var(--_csstools-m-7q9ama-0--size-e); + border-width: var(--_csstools-m-7q9ama-0--initial-untyped); + @apply --registered-private; +} + +.registered-private-b { + + --_csstools-m-7q9ama-1--size: 20px; + --_csstools-m-7q9ama-1--size-a: 30px; + --_csstools-m-7q9ama-1--size-b: 40px; + --_csstools-m-7q9ama-1--size-c: 40px; + --_csstools-m-7q9ama-1--size-d: red, blue; + --_csstools-m-7q9ama-1--size-e: blue; + + width: var(--_csstools-m-7q9ama-1--size); + min-width: var(--_csstools-m-7q9ama-1--initial-size); + height: var(--_csstools-m-7q9ama-1--size-a); + min-height: var(--_csstools-m-7q9ama-1--size-b); + max-height: var(--_csstools-m-7q9ama-1--size-c); + max-width: var(--_csstools-m-7q9ama-1--size-d); + inline-size: var(--_csstools-m-7q9ama-1--size-e); + border-width: var(--_csstools-m-7q9ama-1--initial-untyped); + @apply --registered-private; +} + +@mixin --escaped-private() { + @private { + @property --\66 oo : 20px; + --\66 oo: 30px; + } + + width: var(--\66 oo); +} + +.escaped-private { + --_csstools-m-7q9ama-2--\66 oo: 30px; + + width: var(--_csstools-m-7q9ama-2--foo); + @apply --escaped-private; +} + +@mixin --container-registered() { + @container (width > 10px) { + @private { + @property --container-size : 10px; + --container-size: 20px; + } + } + + width: var(--container-size); +} + +.container-registered { + @container (width > 10px) { + --_csstools-m-7q9ama-3--container-size: 20px + } + + width: var(--_csstools-m-7q9ama-3--container-size); + @apply --container-registered; +} + +@mixin --starting-style-registered() { + @starting-style { + @private { + @property --starting-size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + } + } + + width: var(--starting-size); +} + +.starting-style-registered { + + width: var(--_csstools-m-7q9ama-4--starting-size); + @apply --starting-style-registered; +} + +@mixin --media-registered() { + @private { + @property --media-size : 1em; + --media-size: 2em; + } + + width: var(--media-size); +} + +@media (min-width: 1px) { + .media-registered { + --_csstools-m-7q9ama-5--media-size: 2em; + + width: var(--_csstools-m-7q9ama-5--media-size); + @apply --media-registered; + } +} + +@layer outer { + .layer-registered { + --_csstools-m-7q9ama-6--media-size: 2em; + + width: var(--_csstools-m-7q9ama-6--media-size); + @apply --media-registered; + } +} + +@mixin --anonymous-layer-registered() { + @private { + @property --anonymous-layer-size : 10px; + --anonymous-layer-size: 20px; + } + + width: var(--anonymous-layer-size); +} + +@layer { + .anonymous-layer-registered { + @private { + @property --anonymous-layer-size : 10px; + --anonymous-layer-size: 20px; + } + + width: var(--anonymous-layer-size); + @apply --anonymous-layer-registered; + } +} + +@mixin --plain-after-bail() { + color: green; +} + +@layer { + .anonymous-layer-with-sibling { + color: green; + @apply --plain-after-bail; + @private { + @property --anonymous-layer-size : 10px; + --anonymous-layer-size: 20px; + } + + width: var(--anonymous-layer-size); + @apply --anonymous-layer-registered; + } +} + @property --_csstools-m-7q9ama-0--size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --_csstools-m-7q9ama-0--size-a, --_csstools-m-7q9ama-0--size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --_csstools-m-7q9ama-0--size-c : 12px; + + @property --_csstools-m-7q9ama-0--size-d type(#): red, blue; + + @property --_csstools-m-7q9ama-0--size-e : red; + @property --_csstools-m-7q9ama-0--initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --_csstools-m-7q9ama-0--initial-untyped: 6px; + @property --_csstools-m-7q9ama-1--size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + + @property --_csstools-m-7q9ama-1--size-a, --_csstools-m-7q9ama-1--size-b { + syntax: ""; + inherits: false; + initial-value: 11px; + } + + @property --_csstools-m-7q9ama-1--size-c : 12px; + + @property --_csstools-m-7q9ama-1--size-d type(#): red, blue; + + @property --_csstools-m-7q9ama-1--size-e : red; + @property --_csstools-m-7q9ama-1--initial-size { + syntax: ""; + inherits: false; + initial-value: 5px; + } + + @property --_csstools-m-7q9ama-1--initial-untyped: 6px; + @property --_csstools-m-7q9ama-2--foo : 20px; + @property --_csstools-m-7q9ama-3--container-size : 10px; + @property --_csstools-m-7q9ama-4--starting-size { + syntax: ""; + inherits: false; + initial-value: 10px; + } + +@media (min-width: 1px) { + @property --_csstools-m-7q9ama-5--media-size : 1em +} + +@layer outer { + @property --_csstools-m-7q9ama-6--media-size : 1em +} diff --git a/plugins/postcss-mixins/test/spaces.css b/plugins/postcss-mixins/test/spaces.css index b5a811b8cf..e24e0b5f8c 100644 --- a/plugins/postcss-mixins/test/spaces.css +++ b/plugins/postcss-mixins/test/spaces.css @@ -3,6 +3,18 @@ background-color: var(--background); } +@mixin --multiline-parameters( + --color, + --background, +) { + color: var(--color); + background-color: var(--background); +} + +.multiline-parameters { + @apply --multiline-parameters(green, blue); +} + .space-after-open { @apply --spaces( green, blue); } @@ -90,3 +102,12 @@ .comment-before-default-name { @apply --comment-before-default-name; } + +@mixin --odd-spacing(--color) { + color : var( --color ) ; + width:calc( 1px + 2px ); +} + +.odd-spacing { + @apply --odd-spacing( green ); +} diff --git a/plugins/postcss-mixins/test/spaces.expect.css b/plugins/postcss-mixins/test/spaces.expect.css index f636189cf7..ff5a00010a 100644 --- a/plugins/postcss-mixins/test/spaces.expect.css +++ b/plugins/postcss-mixins/test/spaces.expect.css @@ -1,106 +1,122 @@ +.multiline-parameters { + --_csstools-mix-1kp0udk-arg-0: green; + --_csstools-mix-1kp0udk-arg-1: blue; + --_csstools-m-1kp0udk-0--color: var(--_csstools-mix-1kp0udk-arg-0); + --_csstools-m-1kp0udk-0--background: var(--_csstools-mix-1kp0udk-arg-1); + color: var(--_csstools-m-1kp0udk-0--color); + background-color: var(--_csstools-m-1kp0udk-0--background); +} + .space-after-open { - --_csstools-p-1kp0udk-0--arg-0: green; - --_csstools-p-1kp0udk-0--arg-1: blue; - --_csstools-p-1kp0udk-1--color: var(--_csstools-p-1kp0udk-0--arg-0); - --_csstools-p-1kp0udk-1--background: var(--_csstools-p-1kp0udk-0--arg-1); - color: var(--_csstools-p-1kp0udk-1--color); - background-color: var(--_csstools-p-1kp0udk-1--background); + --_csstools-mix-1kp0udk-arg-2: green; + --_csstools-mix-1kp0udk-arg-3: blue; + --_csstools-m-1kp0udk-1--color: var(--_csstools-mix-1kp0udk-arg-2); + --_csstools-m-1kp0udk-1--background: var(--_csstools-mix-1kp0udk-arg-3); + color: var(--_csstools-m-1kp0udk-1--color); + background-color: var(--_csstools-m-1kp0udk-1--background); } .space-before-close { - --_csstools-p-1kp0udk-2--arg-2: green; - --_csstools-p-1kp0udk-2--arg-3: blue; - --_csstools-p-1kp0udk-3--color: var(--_csstools-p-1kp0udk-2--arg-2); - --_csstools-p-1kp0udk-3--background: var(--_csstools-p-1kp0udk-2--arg-3); - color: var(--_csstools-p-1kp0udk-3--color); - background-color: var(--_csstools-p-1kp0udk-3--background); + --_csstools-mix-1kp0udk-arg-4: green; + --_csstools-mix-1kp0udk-arg-5: blue; + --_csstools-m-1kp0udk-2--color: var(--_csstools-mix-1kp0udk-arg-4); + --_csstools-m-1kp0udk-2--background: var(--_csstools-mix-1kp0udk-arg-5); + color: var(--_csstools-m-1kp0udk-2--color); + background-color: var(--_csstools-m-1kp0udk-2--background); } .space-around-both { - --_csstools-p-1kp0udk-4--arg-4: green; - --_csstools-p-1kp0udk-4--arg-5: blue; - --_csstools-p-1kp0udk-5--color: var(--_csstools-p-1kp0udk-4--arg-4); - --_csstools-p-1kp0udk-5--background: var(--_csstools-p-1kp0udk-4--arg-5); - color: var(--_csstools-p-1kp0udk-5--color); - background-color: var(--_csstools-p-1kp0udk-5--background); + --_csstools-mix-1kp0udk-arg-6: green; + --_csstools-mix-1kp0udk-arg-7: blue; + --_csstools-m-1kp0udk-3--color: var(--_csstools-mix-1kp0udk-arg-6); + --_csstools-m-1kp0udk-3--background: var(--_csstools-mix-1kp0udk-arg-7); + color: var(--_csstools-m-1kp0udk-3--color); + background-color: var(--_csstools-m-1kp0udk-3--background); } .tabs-and-newlines { - --_csstools-p-1kp0udk-6--arg-6: green; - --_csstools-p-1kp0udk-6--arg-7: blue; - --_csstools-p-1kp0udk-7--color: var(--_csstools-p-1kp0udk-6--arg-6); - --_csstools-p-1kp0udk-7--background: var(--_csstools-p-1kp0udk-6--arg-7); - color: var(--_csstools-p-1kp0udk-7--color); - background-color: var(--_csstools-p-1kp0udk-7--background); + --_csstools-mix-1kp0udk-arg-8: green; + --_csstools-mix-1kp0udk-arg-9: blue; + --_csstools-m-1kp0udk-4--color: var(--_csstools-mix-1kp0udk-arg-8); + --_csstools-m-1kp0udk-4--background: var(--_csstools-mix-1kp0udk-arg-9); + color: var(--_csstools-m-1kp0udk-4--color); + background-color: var(--_csstools-m-1kp0udk-4--background); } .space-around-comma { - --_csstools-p-1kp0udk-8--arg-8: green; - --_csstools-p-1kp0udk-8--arg-9: blue; - --_csstools-p-1kp0udk-9--color: var(--_csstools-p-1kp0udk-8--arg-8); - --_csstools-p-1kp0udk-9--background: var(--_csstools-p-1kp0udk-8--arg-9); - color: var(--_csstools-p-1kp0udk-9--color); - background-color: var(--_csstools-p-1kp0udk-9--background); + --_csstools-mix-1kp0udk-arg-10: green; + --_csstools-mix-1kp0udk-arg-11: blue; + --_csstools-m-1kp0udk-5--color: var(--_csstools-mix-1kp0udk-arg-10); + --_csstools-m-1kp0udk-5--background: var(--_csstools-mix-1kp0udk-arg-11); + color: var(--_csstools-m-1kp0udk-5--color); + background-color: var(--_csstools-m-1kp0udk-5--background); } .comment-before-comma { - --_csstools-p-1kp0udk-a--arg-a: green; - --_csstools-p-1kp0udk-a--arg-b: blue; - --_csstools-p-1kp0udk-b--color: var(--_csstools-p-1kp0udk-a--arg-a); - --_csstools-p-1kp0udk-b--background: var(--_csstools-p-1kp0udk-a--arg-b); - color: var(--_csstools-p-1kp0udk-b--color); - background-color: var(--_csstools-p-1kp0udk-b--background); + --_csstools-mix-1kp0udk-arg-12: green /* one */; + --_csstools-mix-1kp0udk-arg-13: blue /* two */; + --_csstools-m-1kp0udk-6--color: var(--_csstools-mix-1kp0udk-arg-12); + --_csstools-m-1kp0udk-6--background: var(--_csstools-mix-1kp0udk-arg-13); + color: var(--_csstools-m-1kp0udk-6--color); + background-color: var(--_csstools-m-1kp0udk-6--background); } .comment-around-arguments { - --_csstools-p-1kp0udk-c--arg-c: green; - --_csstools-p-1kp0udk-c--arg-d: blue; - --_csstools-p-1kp0udk-d--color: var(--_csstools-p-1kp0udk-c--arg-c); - --_csstools-p-1kp0udk-d--background: var(--_csstools-p-1kp0udk-c--arg-d); - color: var(--_csstools-p-1kp0udk-d--color); - background-color: var(--_csstools-p-1kp0udk-d--background); + --_csstools-mix-1kp0udk-arg-14: /* before */ green /* mid */; + --_csstools-mix-1kp0udk-arg-15: blue /* after */; + --_csstools-m-1kp0udk-7--color: var(--_csstools-mix-1kp0udk-arg-14); + --_csstools-m-1kp0udk-7--background: var(--_csstools-mix-1kp0udk-arg-15); + color: var(--_csstools-m-1kp0udk-7--color); + background-color: var(--_csstools-m-1kp0udk-7--background); } .comment-only-default { - --_csstools-p-1kp0udk-e--color: green; - color: var(--_csstools-p-1kp0udk-e--color); + --_csstools-m-1kp0udk-8--color: green; + color: var(--_csstools-m-1kp0udk-8--color); } .space-around-default { - --_csstools-p-1kp0udk-f--color: green; - --_csstools-p-1kp0udk-f--background: blue; - color: var(--_csstools-p-1kp0udk-f--color); - background-color: var(--_csstools-p-1kp0udk-f--background); + --_csstools-m-1kp0udk-9--color: green; + --_csstools-m-1kp0udk-9--background: blue; + color: var(--_csstools-m-1kp0udk-9--color); + background-color: var(--_csstools-m-1kp0udk-9--background); } .space-around-argument-defaults { - --_csstools-p-1kp0udk-g--arg-e: red; - --_csstools-p-1kp0udk-g--arg-f: blue; - --_csstools-p-1kp0udk-h--color: var(--_csstools-p-1kp0udk-g--arg-e); - --_csstools-p-1kp0udk-h--background: var(--_csstools-p-1kp0udk-g--arg-f); - color: var(--_csstools-p-1kp0udk-h--color); - background-color: var(--_csstools-p-1kp0udk-h--background); + --_csstools-mix-1kp0udk-arg-16: red; + --_csstools-mix-1kp0udk-arg-17: blue; + --_csstools-m-1kp0udk-a--color: var(--_csstools-mix-1kp0udk-arg-16); + --_csstools-m-1kp0udk-a--background: var(--_csstools-mix-1kp0udk-arg-17); + color: var(--_csstools-m-1kp0udk-a--color); + background-color: var(--_csstools-m-1kp0udk-a--background); } .comment-before-parameter-name { - --_csstools-p-1kp0udk-i--arg-g: green; - --_csstools-p-1kp0udk-i--arg-h: blue; - --_csstools-p-1kp0udk-j--color: var(--_csstools-p-1kp0udk-i--arg-g); - --_csstools-p-1kp0udk-j--background: var(--_csstools-p-1kp0udk-i--arg-h); - color: var(--_csstools-p-1kp0udk-j--color); - background-color: var(--_csstools-p-1kp0udk-j--background); + --_csstools-mix-1kp0udk-arg-18: green; + --_csstools-mix-1kp0udk-arg-19: blue; + --_csstools-m-1kp0udk-b--color: var(--_csstools-mix-1kp0udk-arg-18); + --_csstools-m-1kp0udk-b--background: var(--_csstools-mix-1kp0udk-arg-19); + color: var(--_csstools-m-1kp0udk-b--color); + background-color: var(--_csstools-m-1kp0udk-b--background); } .space-before-parameter-name { - --_csstools-p-1kp0udk-k--arg-i: green; - --_csstools-p-1kp0udk-k--arg-j: blue; - --_csstools-p-1kp0udk-l--color: var(--_csstools-p-1kp0udk-k--arg-i); - --_csstools-p-1kp0udk-l--background: var(--_csstools-p-1kp0udk-k--arg-j); - color: var(--_csstools-p-1kp0udk-l--color); - background-color: var(--_csstools-p-1kp0udk-l--background); + --_csstools-mix-1kp0udk-arg-20: green; + --_csstools-mix-1kp0udk-arg-21: blue; + --_csstools-m-1kp0udk-c--color: var(--_csstools-mix-1kp0udk-arg-20); + --_csstools-m-1kp0udk-c--background: var(--_csstools-mix-1kp0udk-arg-21); + color: var(--_csstools-m-1kp0udk-c--color); + background-color: var(--_csstools-m-1kp0udk-c--background); } .comment-before-default-name { - --_csstools-p-1kp0udk-m--color: green; - color: var(--_csstools-p-1kp0udk-m--color); + --_csstools-m-1kp0udk-d--color: green; + color: var(--_csstools-m-1kp0udk-d--color); +} + +.odd-spacing { + --_csstools-mix-1kp0udk-arg-22: green; + --_csstools-m-1kp0udk-e--color: var(--_csstools-mix-1kp0udk-arg-22); + color : var( --_csstools-m-1kp0udk-e--color ); + width:calc( 1px + 2px ); } diff --git a/plugins/postcss-mixins/test/spaces.preserve-true.expect.css b/plugins/postcss-mixins/test/spaces.preserve-true.expect.css index b250a19872..b8f0470138 100644 --- a/plugins/postcss-mixins/test/spaces.preserve-true.expect.css +++ b/plugins/postcss-mixins/test/spaces.preserve-true.expect.css @@ -3,43 +3,61 @@ background-color: var(--background); } +@mixin --multiline-parameters( + --color, + --background, +) { + color: var(--color); + background-color: var(--background); +} + +.multiline-parameters { + --_csstools-mix-1kp0udk-arg-0: green; + --_csstools-mix-1kp0udk-arg-1: blue; + --_csstools-m-1kp0udk-0--color: var(--_csstools-mix-1kp0udk-arg-0); + --_csstools-m-1kp0udk-0--background: var(--_csstools-mix-1kp0udk-arg-1); + color: var(--_csstools-m-1kp0udk-0--color); + background-color: var(--_csstools-m-1kp0udk-0--background); + @apply --multiline-parameters(green, blue); +} + .space-after-open { - --_csstools-p-1kp0udk-0--arg-0: green; - --_csstools-p-1kp0udk-0--arg-1: blue; - --_csstools-p-1kp0udk-1--color: var(--_csstools-p-1kp0udk-0--arg-0); - --_csstools-p-1kp0udk-1--background: var(--_csstools-p-1kp0udk-0--arg-1); - color: var(--_csstools-p-1kp0udk-1--color); - background-color: var(--_csstools-p-1kp0udk-1--background); + --_csstools-mix-1kp0udk-arg-2: green; + --_csstools-mix-1kp0udk-arg-3: blue; + --_csstools-m-1kp0udk-1--color: var(--_csstools-mix-1kp0udk-arg-2); + --_csstools-m-1kp0udk-1--background: var(--_csstools-mix-1kp0udk-arg-3); + color: var(--_csstools-m-1kp0udk-1--color); + background-color: var(--_csstools-m-1kp0udk-1--background); @apply --spaces( green, blue); } .space-before-close { - --_csstools-p-1kp0udk-2--arg-2: green; - --_csstools-p-1kp0udk-2--arg-3: blue; - --_csstools-p-1kp0udk-3--color: var(--_csstools-p-1kp0udk-2--arg-2); - --_csstools-p-1kp0udk-3--background: var(--_csstools-p-1kp0udk-2--arg-3); - color: var(--_csstools-p-1kp0udk-3--color); - background-color: var(--_csstools-p-1kp0udk-3--background); + --_csstools-mix-1kp0udk-arg-4: green; + --_csstools-mix-1kp0udk-arg-5: blue; + --_csstools-m-1kp0udk-2--color: var(--_csstools-mix-1kp0udk-arg-4); + --_csstools-m-1kp0udk-2--background: var(--_csstools-mix-1kp0udk-arg-5); + color: var(--_csstools-m-1kp0udk-2--color); + background-color: var(--_csstools-m-1kp0udk-2--background); @apply --spaces(green, blue ); } .space-around-both { - --_csstools-p-1kp0udk-4--arg-4: green; - --_csstools-p-1kp0udk-4--arg-5: blue; - --_csstools-p-1kp0udk-5--color: var(--_csstools-p-1kp0udk-4--arg-4); - --_csstools-p-1kp0udk-5--background: var(--_csstools-p-1kp0udk-4--arg-5); - color: var(--_csstools-p-1kp0udk-5--color); - background-color: var(--_csstools-p-1kp0udk-5--background); + --_csstools-mix-1kp0udk-arg-6: green; + --_csstools-mix-1kp0udk-arg-7: blue; + --_csstools-m-1kp0udk-3--color: var(--_csstools-mix-1kp0udk-arg-6); + --_csstools-m-1kp0udk-3--background: var(--_csstools-mix-1kp0udk-arg-7); + color: var(--_csstools-m-1kp0udk-3--color); + background-color: var(--_csstools-m-1kp0udk-3--background); @apply --spaces( green, blue ); } .tabs-and-newlines { - --_csstools-p-1kp0udk-6--arg-6: green; - --_csstools-p-1kp0udk-6--arg-7: blue; - --_csstools-p-1kp0udk-7--color: var(--_csstools-p-1kp0udk-6--arg-6); - --_csstools-p-1kp0udk-7--background: var(--_csstools-p-1kp0udk-6--arg-7); - color: var(--_csstools-p-1kp0udk-7--color); - background-color: var(--_csstools-p-1kp0udk-7--background); + --_csstools-mix-1kp0udk-arg-8: green; + --_csstools-mix-1kp0udk-arg-9: blue; + --_csstools-m-1kp0udk-4--color: var(--_csstools-mix-1kp0udk-arg-8); + --_csstools-m-1kp0udk-4--background: var(--_csstools-mix-1kp0udk-arg-9); + color: var(--_csstools-m-1kp0udk-4--color); + background-color: var(--_csstools-m-1kp0udk-4--background); @apply --spaces( green, blue @@ -47,12 +65,12 @@ } .space-around-comma { - --_csstools-p-1kp0udk-8--arg-8: green; - --_csstools-p-1kp0udk-8--arg-9: blue; - --_csstools-p-1kp0udk-9--color: var(--_csstools-p-1kp0udk-8--arg-8); - --_csstools-p-1kp0udk-9--background: var(--_csstools-p-1kp0udk-8--arg-9); - color: var(--_csstools-p-1kp0udk-9--color); - background-color: var(--_csstools-p-1kp0udk-9--background); + --_csstools-mix-1kp0udk-arg-10: green; + --_csstools-mix-1kp0udk-arg-11: blue; + --_csstools-m-1kp0udk-5--color: var(--_csstools-mix-1kp0udk-arg-10); + --_csstools-m-1kp0udk-5--background: var(--_csstools-mix-1kp0udk-arg-11); + color: var(--_csstools-m-1kp0udk-5--color); + background-color: var(--_csstools-m-1kp0udk-5--background); @apply --spaces(green , blue); } @@ -62,12 +80,12 @@ } .comment-before-comma { - --_csstools-p-1kp0udk-a--arg-a: green; - --_csstools-p-1kp0udk-a--arg-b: blue; - --_csstools-p-1kp0udk-b--color: var(--_csstools-p-1kp0udk-a--arg-a); - --_csstools-p-1kp0udk-b--background: var(--_csstools-p-1kp0udk-a--arg-b); - color: var(--_csstools-p-1kp0udk-b--color); - background-color: var(--_csstools-p-1kp0udk-b--background); + --_csstools-mix-1kp0udk-arg-12: green /* one */; + --_csstools-mix-1kp0udk-arg-13: blue /* two */; + --_csstools-m-1kp0udk-6--color: var(--_csstools-mix-1kp0udk-arg-12); + --_csstools-m-1kp0udk-6--background: var(--_csstools-mix-1kp0udk-arg-13); + color: var(--_csstools-m-1kp0udk-6--color); + background-color: var(--_csstools-m-1kp0udk-6--background); @apply --comment-in-parameters(green /* one */, blue /* two */); } @@ -77,12 +95,12 @@ } .comment-around-arguments { - --_csstools-p-1kp0udk-c--arg-c: green; - --_csstools-p-1kp0udk-c--arg-d: blue; - --_csstools-p-1kp0udk-d--color: var(--_csstools-p-1kp0udk-c--arg-c); - --_csstools-p-1kp0udk-d--background: var(--_csstools-p-1kp0udk-c--arg-d); - color: var(--_csstools-p-1kp0udk-d--color); - background-color: var(--_csstools-p-1kp0udk-d--background); + --_csstools-mix-1kp0udk-arg-14: /* before */ green /* mid */; + --_csstools-mix-1kp0udk-arg-15: blue /* after */; + --_csstools-m-1kp0udk-7--color: var(--_csstools-mix-1kp0udk-arg-14); + --_csstools-m-1kp0udk-7--background: var(--_csstools-mix-1kp0udk-arg-15); + color: var(--_csstools-m-1kp0udk-7--color); + background-color: var(--_csstools-m-1kp0udk-7--background); @apply --comment-parameters-and-arguments( /* before */ green /* mid */, blue /* after */ ); } @@ -91,8 +109,8 @@ } .comment-only-default { - --_csstools-p-1kp0udk-e--color: green; - color: var(--_csstools-p-1kp0udk-e--color); + --_csstools-m-1kp0udk-8--color: green; + color: var(--_csstools-m-1kp0udk-8--color); @apply --comment-only-default; } @@ -102,20 +120,20 @@ } .space-around-default { - --_csstools-p-1kp0udk-f--color: green; - --_csstools-p-1kp0udk-f--background: blue; - color: var(--_csstools-p-1kp0udk-f--color); - background-color: var(--_csstools-p-1kp0udk-f--background); + --_csstools-m-1kp0udk-9--color: green; + --_csstools-m-1kp0udk-9--background: blue; + color: var(--_csstools-m-1kp0udk-9--color); + background-color: var(--_csstools-m-1kp0udk-9--background); @apply --space-around-default; } .space-around-argument-defaults { - --_csstools-p-1kp0udk-g--arg-e: red; - --_csstools-p-1kp0udk-g--arg-f: blue; - --_csstools-p-1kp0udk-h--color: var(--_csstools-p-1kp0udk-g--arg-e); - --_csstools-p-1kp0udk-h--background: var(--_csstools-p-1kp0udk-g--arg-f); - color: var(--_csstools-p-1kp0udk-h--color); - background-color: var(--_csstools-p-1kp0udk-h--background); + --_csstools-mix-1kp0udk-arg-16: red; + --_csstools-mix-1kp0udk-arg-17: blue; + --_csstools-m-1kp0udk-a--color: var(--_csstools-mix-1kp0udk-arg-16); + --_csstools-m-1kp0udk-a--background: var(--_csstools-mix-1kp0udk-arg-17); + color: var(--_csstools-m-1kp0udk-a--color); + background-color: var(--_csstools-m-1kp0udk-a--background); @apply --space-around-default( red , blue ); } @@ -125,12 +143,12 @@ } .comment-before-parameter-name { - --_csstools-p-1kp0udk-i--arg-g: green; - --_csstools-p-1kp0udk-i--arg-h: blue; - --_csstools-p-1kp0udk-j--color: var(--_csstools-p-1kp0udk-i--arg-g); - --_csstools-p-1kp0udk-j--background: var(--_csstools-p-1kp0udk-i--arg-h); - color: var(--_csstools-p-1kp0udk-j--color); - background-color: var(--_csstools-p-1kp0udk-j--background); + --_csstools-mix-1kp0udk-arg-18: green; + --_csstools-mix-1kp0udk-arg-19: blue; + --_csstools-m-1kp0udk-b--color: var(--_csstools-mix-1kp0udk-arg-18); + --_csstools-m-1kp0udk-b--background: var(--_csstools-mix-1kp0udk-arg-19); + color: var(--_csstools-m-1kp0udk-b--color); + background-color: var(--_csstools-m-1kp0udk-b--background); @apply --comment-before-parameter-name(green, blue); } @@ -140,12 +158,12 @@ } .space-before-parameter-name { - --_csstools-p-1kp0udk-k--arg-i: green; - --_csstools-p-1kp0udk-k--arg-j: blue; - --_csstools-p-1kp0udk-l--color: var(--_csstools-p-1kp0udk-k--arg-i); - --_csstools-p-1kp0udk-l--background: var(--_csstools-p-1kp0udk-k--arg-j); - color: var(--_csstools-p-1kp0udk-l--color); - background-color: var(--_csstools-p-1kp0udk-l--background); + --_csstools-mix-1kp0udk-arg-20: green; + --_csstools-mix-1kp0udk-arg-21: blue; + --_csstools-m-1kp0udk-c--color: var(--_csstools-mix-1kp0udk-arg-20); + --_csstools-m-1kp0udk-c--background: var(--_csstools-mix-1kp0udk-arg-21); + color: var(--_csstools-m-1kp0udk-c--color); + background-color: var(--_csstools-m-1kp0udk-c--background); @apply --space-before-parameter-name(green, blue); } @@ -154,7 +172,20 @@ } .comment-before-default-name { - --_csstools-p-1kp0udk-m--color: green; - color: var(--_csstools-p-1kp0udk-m--color); + --_csstools-m-1kp0udk-d--color: green; + color: var(--_csstools-m-1kp0udk-d--color); @apply --comment-before-default-name; } + +@mixin --odd-spacing(--color) { + color : var( --color ) ; + width:calc( 1px + 2px ); +} + +.odd-spacing { + --_csstools-mix-1kp0udk-arg-22: green; + --_csstools-m-1kp0udk-e--color: var(--_csstools-mix-1kp0udk-arg-22); + color : var( --_csstools-m-1kp0udk-e--color ); + width:calc( 1px + 2px ); + @apply --odd-spacing( green ); +} diff --git a/plugins/postcss-mixins/test/wpt/mixin-arguments.html b/plugins/postcss-mixins/test/wpt/mixin-arguments.html index 5958c47c92..badb57b9ad 100644 --- a/plugins/postcss-mixins/test/wpt/mixin-arguments.html +++ b/plugins/postcss-mixins/test/wpt/mixin-arguments.html @@ -12,6 +12,13 @@ + + + + + + +