@atomicsmash/coding-standards 17.0.3-beta.0 → 18.0.0-beta.10

package/dist/stylelint/base.js

@@ -0,0 +1,86 @@
+const commonRules = {
+    "custom-property-pattern": null,
+    "function-url-quotes": ["always"],
+    "rule-empty-line-before": [
+        "always",
+        {
+            except: ["first-nested"],
+            ignore: ["after-comment"],
+        },
+    ],
+    "comment-empty-line-before": [
+        "always",
+        {
+            except: ["first-nested"],
+            ignore: ["stylelint-commands"],
+        },
+    ],
+    "order/order": [
+        {
+            type: "at-rule",
+            hasBlock: false,
+        },
+        "custom-properties",
+        "dollar-variables",
+        "declarations",
+        {
+            type: "at-rule",
+            hasBlock: true,
+        },
+        "rules",
+    ],
+    "plugin/no-restricted-syntax": [
+        [
+            {
+                selector: "rule :matches(atrule[name=media], atrule[name=container]) rule",
+                message: "Don't nest rules inside of media/container blocks. Instead, nest the rule and use the at rule within that.",
+            },
+        ],
+    ],
+    "selector-class-pattern": [
+        "^([a-z][a-z0-9]*)([_-]+[a-z0-9]+)*$",
+        {
+            message: "Selector should use lowercase and separate words with hyphens or underscores (selector-class-pattern)",
+        },
+    ],
+    "at-rule-empty-line-before": [
+        "always",
+        {
+            ignore: ["blockless-after-blockless", "first-nested", "after-comment"],
+        },
+    ],
+};
+export default {
+    reportDescriptionlessDisables: true,
+    reportInvalidScopeDisables: true,
+    reportNeedlessDisables: true,
+    plugins: ["stylelint-order", "stylelint-no-restricted-syntax"],
+    rules: commonRules,
+    overrides: [
+        {
+            files: ["*.css", "**/*.css"],
+            extends: ["stylelint-config-standard", "@wordpress/stylelint-config"],
+            rules: {
+                "at-rule-no-unknown": [true, { ignoreAtRules: "context" }],
+            },
+        },
+        {
+            files: ["*.scss", "**/*.scss"],
+            extends: [
+                "stylelint-config-standard-scss",
+                "@wordpress/stylelint-config/scss",
+            ],
+            rules: {
+                "scss/operator-no-newline-after": null,
+                "no-descending-specificity": null,
+                "scss/at-rule-no-unknown": [true, { ignoreAtRules: "context" }],
+            },
+        },
+        {
+            files: ["**/editor-style?(s).?(s)css"],
+            rules: {
+                "declaration-property-value-allowed-list": null,
+            },
+        },
+    ],
+};

package/dist/stylelint/classic.d.ts

@@ -0,0 +1,69 @@
+declare const _default: {
+    reportDescriptionlessDisables: true;
+    reportInvalidScopeDisables: true;
+    reportNeedlessDisables: true;
+    plugins: string[];
+    rules: {
+        "custom-property-pattern": null;
+        "function-url-quotes": string[];
+        "rule-empty-line-before": (string | {
+            except: string[];
+            ignore: string[];
+        })[];
+        "comment-empty-line-before": (string | {
+            except: string[];
+            ignore: string[];
+        })[];
+        "order/order": (string | {
+            type: string;
+            hasBlock: boolean;
+        })[];
+        "plugin/no-restricted-syntax": {
+            selector: string;
+            message: string;
+        }[][];
+        "selector-class-pattern": (string | {
+            message: string;
+        })[];
+        "at-rule-empty-line-before": (string | {
+            ignore: string[];
+        })[];
+    };
+    overrides: ({
+        files: string[];
+        extends: string[];
+        rules: {
+            "at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string;
+            })[];
+            "scss/operator-no-newline-after"?: undefined;
+            "no-descending-specificity"?: undefined;
+            "scss/at-rule-no-unknown"?: undefined;
+            "declaration-property-value-allowed-list"?: undefined;
+        };
+    } | {
+        files: string[];
+        extends: string[];
+        rules: {
+            "scss/operator-no-newline-after": null;
+            "no-descending-specificity": null;
+            "scss/at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string;
+            })[];
+            "at-rule-no-unknown"?: undefined;
+            "declaration-property-value-allowed-list"?: undefined;
+        };
+    } | {
+        files: string[];
+        rules: {
+            "declaration-property-value-allowed-list": null;
+            "at-rule-no-unknown"?: undefined;
+            "scss/operator-no-newline-after"?: undefined;
+            "no-descending-specificity"?: undefined;
+            "scss/at-rule-no-unknown"?: undefined;
+        };
+        extends?: undefined;
+    })[];
+};
+export default _default;
+//# sourceMappingURL=classic.d.ts.map

package/dist/stylelint/classic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classic.d.ts","sourceRoot":"","sources":["../../src/stylelint/classic.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAAuC"}

package/dist/stylelint/classic.js

@@ -0,0 +1,2 @@
+import config from "./base.js";
+export default config;

package/dist/stylelint/index.d.ts

@@ -0,0 +1,161 @@
+declare const _default: {
+    classic: {
+        reportDescriptionlessDisables: true;
+        reportInvalidScopeDisables: true;
+        reportNeedlessDisables: true;
+        plugins: string[];
+        rules: {
+            "custom-property-pattern": null;
+            "function-url-quotes": string[];
+            "rule-empty-line-before": (string | {
+                except: string[];
+                ignore: string[];
+            })[];
+            "comment-empty-line-before": (string | {
+                except: string[];
+                ignore: string[];
+            })[];
+            "order/order": (string | {
+                type: string;
+                hasBlock: boolean;
+            })[];
+            "plugin/no-restricted-syntax": {
+                selector: string;
+                message: string;
+            }[][];
+            "selector-class-pattern": (string | {
+                message: string;
+            })[];
+            "at-rule-empty-line-before": (string | {
+                ignore: string[];
+            })[];
+        };
+        overrides: ({
+            files: string[];
+            extends: string[];
+            rules: {
+                "at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string;
+                })[];
+                "scss/operator-no-newline-after"?: undefined;
+                "no-descending-specificity"?: undefined;
+                "scss/at-rule-no-unknown"?: undefined;
+                "declaration-property-value-allowed-list"?: undefined;
+            };
+        } | {
+            files: string[];
+            extends: string[];
+            rules: {
+                "scss/operator-no-newline-after": null;
+                "no-descending-specificity": null;
+                "scss/at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string;
+                })[];
+                "at-rule-no-unknown"?: undefined;
+                "declaration-property-value-allowed-list"?: undefined;
+            };
+        } | {
+            files: string[];
+            rules: {
+                "declaration-property-value-allowed-list": null;
+                "at-rule-no-unknown"?: undefined;
+                "scss/operator-no-newline-after"?: undefined;
+                "no-descending-specificity"?: undefined;
+                "scss/at-rule-no-unknown"?: undefined;
+            };
+            extends?: undefined;
+        })[];
+    };
+    themeJson: {
+        rules: {
+            "declaration-property-value-allowed-list": (Record<string, string[]> | {
+                severity: string;
+                message: (property: string, value: string) => string;
+            })[];
+            "custom-property-pattern": null;
+            "function-url-quotes": string[];
+            "rule-empty-line-before": (string | {
+                except: string[];
+                ignore: string[];
+            })[];
+            "comment-empty-line-before": (string | {
+                except: string[];
+                ignore: string[];
+            })[];
+            "order/order": (string | {
+                type: string;
+                hasBlock: boolean;
+            })[];
+            "plugin/no-restricted-syntax": {
+                selector: string;
+                message: string;
+            }[][];
+            "selector-class-pattern": (string | {
+                message: string;
+            })[];
+            "at-rule-empty-line-before": (string | {
+                ignore: string[];
+            })[];
+        };
+        reportDescriptionlessDisables: true;
+        reportInvalidScopeDisables: true;
+        reportNeedlessDisables: true;
+        plugins: string[];
+        overrides: ({
+            files: string[];
+            extends: string[];
+            rules: {
+                "at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string;
+                })[];
+                "scss/operator-no-newline-after"?: undefined;
+                "no-descending-specificity"?: undefined;
+                "scss/at-rule-no-unknown"?: undefined;
+                "declaration-property-value-allowed-list"?: undefined;
+            };
+        } | {
+            files: string[];
+            extends: string[];
+            rules: {
+                "scss/operator-no-newline-after": null;
+                "no-descending-specificity": null;
+                "scss/at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string;
+                })[];
+                "at-rule-no-unknown"?: undefined;
+                "declaration-property-value-allowed-list"?: undefined;
+            };
+        } | {
+            files: string[];
+            rules: {
+                "declaration-property-value-allowed-list": null;
+                "at-rule-no-unknown"?: undefined;
+                "scss/operator-no-newline-after"?: undefined;
+                "no-descending-specificity"?: undefined;
+                "scss/at-rule-no-unknown"?: undefined;
+            };
+            extends?: undefined;
+        })[];
+    };
+    tailwind: {
+        overrides: ({
+            files: string[];
+            rules: {
+                "at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string[];
+                })[];
+                "scss/at-rule-no-unknown"?: undefined;
+            };
+        } | {
+            files: string[];
+            rules: {
+                "scss/at-rule-no-unknown": (boolean | {
+                    ignoreAtRules: string[];
+                })[];
+                "at-rule-no-unknown"?: undefined;
+            };
+        })[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/stylelint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stylelint/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAAgD"}

package/dist/stylelint/index.js

@@ -0,0 +1,4 @@
+import { default as classic } from "./classic.js";
+import { default as tailwind } from "./tailwind.js";
+import { default as themeJson } from "./theme-json.js";
+export default { classic, themeJson, tailwind };

package/dist/stylelint/tailwind.d.ts

@@ -0,0 +1,21 @@
+declare const _default: {
+    overrides: ({
+        files: string[];
+        rules: {
+            "at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string[];
+            })[];
+            "scss/at-rule-no-unknown"?: undefined;
+        };
+    } | {
+        files: string[];
+        rules: {
+            "scss/at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string[];
+            })[];
+            "at-rule-no-unknown"?: undefined;
+        };
+    })[];
+};
+export default _default;
+//# sourceMappingURL=tailwind.d.ts.map

package/dist/stylelint/tailwind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind.d.ts","sourceRoot":"","sources":["../../src/stylelint/tailwind.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAEA,wBAqCmB"}

package/dist/stylelint/tailwind.js

@@ -0,0 +1,38 @@
+export default {
+    overrides: [
+        {
+            files: ["*.css", "**/*.css"],
+            rules: {
+                "at-rule-no-unknown": [
+                    true,
+                    {
+                        ignoreAtRules: [
+                            "tailwind",
+                            "apply",
+                            "variants",
+                            "responsive",
+                            "screen",
+                        ],
+                    },
+                ],
+            },
+        },
+        {
+            files: ["*.scss", "**/*.scss"],
+            rules: {
+                "scss/at-rule-no-unknown": [
+                    true,
+                    {
+                        ignoreAtRules: [
+                            "tailwind",
+                            "apply",
+                            "variants",
+                            "responsive",
+                            "screen",
+                        ],
+                    },
+                ],
+            },
+        },
+    ],
+};

package/dist/stylelint/theme-json.d.ts

@@ -0,0 +1,73 @@
+declare const _default: {
+    rules: {
+        "declaration-property-value-allowed-list": (Record<string, string[]> | {
+            severity: string;
+            message: (property: string, value: string) => string;
+        })[];
+        "custom-property-pattern": null;
+        "function-url-quotes": string[];
+        "rule-empty-line-before": (string | {
+            except: string[];
+            ignore: string[];
+        })[];
+        "comment-empty-line-before": (string | {
+            except: string[];
+            ignore: string[];
+        })[];
+        "order/order": (string | {
+            type: string;
+            hasBlock: boolean;
+        })[];
+        "plugin/no-restricted-syntax": {
+            selector: string;
+            message: string;
+        }[][];
+        "selector-class-pattern": (string | {
+            message: string;
+        })[];
+        "at-rule-empty-line-before": (string | {
+            ignore: string[];
+        })[];
+    };
+    reportDescriptionlessDisables: true;
+    reportInvalidScopeDisables: true;
+    reportNeedlessDisables: true;
+    plugins: string[];
+    overrides: ({
+        files: string[];
+        extends: string[];
+        rules: {
+            "at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string;
+            })[];
+            "scss/operator-no-newline-after"?: undefined;
+            "no-descending-specificity"?: undefined;
+            "scss/at-rule-no-unknown"?: undefined;
+            "declaration-property-value-allowed-list"?: undefined;
+        };
+    } | {
+        files: string[];
+        extends: string[];
+        rules: {
+            "scss/operator-no-newline-after": null;
+            "no-descending-specificity": null;
+            "scss/at-rule-no-unknown": (boolean | {
+                ignoreAtRules: string;
+            })[];
+            "at-rule-no-unknown"?: undefined;
+            "declaration-property-value-allowed-list"?: undefined;
+        };
+    } | {
+        files: string[];
+        rules: {
+            "declaration-property-value-allowed-list": null;
+            "at-rule-no-unknown"?: undefined;
+            "scss/operator-no-newline-after"?: undefined;
+            "no-descending-specificity"?: undefined;
+            "scss/at-rule-no-unknown"?: undefined;
+        };
+        extends?: undefined;
+    })[];
+};
+export default _default;
+//# sourceMappingURL=theme-json.d.ts.map

package/dist/stylelint/theme-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-json.d.ts","sourceRoot":"","sources":["../../src/stylelint/theme-json.ts"],"names":[],"mappings":";;;;gCAqIuB,MAAM,SAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgD5C,wBAMmB"}

package/dist/stylelint/theme-json.js

@@ -0,0 +1,169 @@
+import baseConfig from "./base.js";
+function createAllowedPropertyList(values) {
+    const allowedPropertyList = {};
+    for (const { property, varInfo, shorthand = 1, additionalAllowedValues = [], } of values) {
+        const isRegexProperty = property instanceof RegExp;
+        const possibleValues = [];
+        const possibleVars = [
+            ...additionalAllowedValues.map((value) => value instanceof RegExp ? value.toString() : value),
+            `(var\\([\\s]*--wp--${varInfo.type}--${varInfo.slug}--([a-z-0-9]+[\\s]*)\\))`,
+        ];
+        if (isRegexProperty) {
+            possibleVars.push(`(var\\([\\s]*--[a-z-0-9]*${property.toString().slice(1, -1)}[a-z-0-9]*[\\s]*\\))`);
+        }
+        else if (property) {
+            possibleVars.push(`(var\\([\\s]*--[a-z-0-9]*${property}[a-z-0-9]*[\\s]*\\))`);
+        }
+        possibleValues.push(
+        // For each shorthand value, allow one of the possible values followed by a space, or allow it to be blank
+        `/^${shorthand > 1 ? `((${possibleVars.join("|")})[\\s]*){0,${(shorthand - 1).toString()}}` : ""}(${possibleVars.join("|")})$/`);
+        allowedPropertyList[property.toString()] = possibleValues;
+        if (!isRegexProperty) {
+            allowedPropertyList[`/--[a-z-0-9]*${property}[a-z-0-9]*/`] =
+                possibleValues;
+        }
+    }
+    return allowedPropertyList;
+}
+const rules = {
+    "declaration-property-value-allowed-list": [
+        createAllowedPropertyList([
+            {
+                property: /border((-top|-bottom)(-left|-right))?-radius/,
+                varInfo: {
+                    type: "custom",
+                    slug: "radius",
+                },
+            },
+            {
+                property: "border-radius",
+                varInfo: {
+                    type: "custom",
+                    slug: "radius",
+                },
+                shorthand: 4,
+            },
+            {
+                property: "box-shadow",
+                varInfo: {
+                    type: "preset",
+                    slug: "shadow",
+                },
+                additionalAllowedValues: ["none", "unset"],
+            },
+            {
+                property: /color/,
+                varInfo: {
+                    type: "preset",
+                    slug: "color",
+                },
+                additionalAllowedValues: ["inherit", "currentcolor"],
+            },
+            {
+                property: "background-color",
+                varInfo: {
+                    type: "preset",
+                    slug: "color",
+                },
+                additionalAllowedValues: ["transparent"],
+            },
+            {
+                property: "font-family",
+                varInfo: {
+                    type: "preset",
+                    slug: "font-family",
+                },
+                additionalAllowedValues: ["inherit"],
+            },
+            {
+                property: "font-size",
+                varInfo: {
+                    type: "preset",
+                    slug: "font-size",
+                },
+                additionalAllowedValues: ["inherit"],
+            },
+            {
+                property: /(?<!scroll-)margin/,
+                varInfo: {
+                    type: "preset",
+                    slug: "spacing",
+                },
+                shorthand: 4,
+                additionalAllowedValues: ["auto", "var\\(--wp--style--block-gap\\)"],
+            },
+            {
+                property: /padding/,
+                varInfo: {
+                    type: "preset",
+                    slug: "spacing",
+                },
+                shorthand: 4,
+            },
+            {
+                property: "z-index",
+                varInfo: {
+                    type: "custom",
+                    slug: "z-index",
+                },
+            },
+        ]),
+        {
+            severity: "warning",
+            message: (property, value) => {
+                // Until updated, property and value will always return undefined.
+                return `Most values for this type of property should be defined in theme.json. (declaration-property-value-allowed-list)`;
+                // The following code is not complete, it has been left to show how this function could provide more helpful error
+                // messages once an update to stylelint is possible.
+                let message = `Invalid property provided for ${property}.`;
+                let ruleKey;
+                if (property.includes("color")) {
+                    ruleKey = "/color/";
+                }
+                else if (property.includes("margin")) {
+                    ruleKey = "/margin/";
+                }
+                else if (property.includes("padding")) {
+                    ruleKey = "/padding/";
+                }
+                else {
+                    ruleKey = property;
+                }
+                switch (ruleKey) {
+                    case "z-index": {
+                        message = `z-index must use one of the values specified in the theme.json file under \`settings.custom.z-index\`.`;
+                        break;
+                    }
+                    case "/color/": {
+                        message = `Colour values must use one of the values specified in the theme.json file under \`settings.color.palette\`.`;
+                        break;
+                    }
+                    case "/margin/": {
+                        message = `Margin values must use one of the values specified in the theme.json file under \`settings.spacing.spacingSizes\`.`;
+                        break;
+                    }
+                    case "/padding/": {
+                        message = `Padding values must use one of the values specified in the theme.json file under \`settings.spacing.spacingSizes\`.`;
+                        break;
+                    }
+                    case "font-size": {
+                        message = `Font size values must use one of the values specified in the theme.json file under \`settings.typography.fontSizes\`.`;
+                        break;
+                    }
+                    case "font-family": {
+                        message = `Font family values must use one of the values specified in the theme.json file under \`settings.typography.fontFamilies\`.`;
+                        break;
+                    }
+                }
+                return `${message} Value provided: ${value} (declaration-property-value-allowed-list)`;
+            },
+        },
+    ],
+};
+export default {
+    ...baseConfig,
+    rules: {
+        ...baseConfig.rules,
+        ...rules,
+    },
+};