@atomicsmash/coding-standards 18.0.0-beta.6 → 18.0.0-beta.8

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,
+    },
+};

package/package.json

@@ -1,34 +1,62 @@
 {
 	"name": "@atomicsmash/coding-standards",
 	"type": "module",
-	"version": "18.0.0-beta.6",
+	"version": "18.0.0-beta.8",
 	"description": "A collection of coding standards configurations.",
-	"main": "index.js",
-	"types": "index.d.ts",
+	"files": [
+		"./dist/**/*",
+		"./typescript/**/*",
+		"./beta/**/*",
+		"CHANGELOG.md",
+		"MIGRATING.md",
+		"package.json"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./cspell": {
+			"types": "./dist/cspell/index.d.ts",
+			"default": "./dist/cspell/index.js"
+		},
+		"./eslint": {
+			"types": "./dist/eslint/index.d.ts",
+			"default": "./dist/eslint/index.js"
+		},
+		"./prettier": {
+			"types": "./dist/prettier/index.d.ts",
+			"default": "./dist/prettier/index.js"
+		},
+		"./stylelint/*": {
+			"types": "./dist/stylelint/*.d.ts",
+			"default": "./dist/stylelint/*.js"
+		},
+		"./typescript/*": "./typescript/*.json",
+		"./beta/biome": "./beta/biome/biome.jsonc"
+	},
 	"devDependencies": {
 		"@cspell/cspell-types": "^9.7.0"
 	},
 	"peerDependencies": {
-		"@atomicsmash/browserslist-config": "^18.0.0-beta.6",
-		"@atomicsmash/eslint-config": "^18.0.0-beta.6",
-		"@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
-		"@eslint/js": "^8.57.1",
+		"@atomicsmash/browserslist-config": "^18.0.0-beta.8",
+		"@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
+		"@eslint/js": "^10.0.1",
 		"@wordpress/stylelint-config": "^23.33.0",
-		"eslint": "^8.57.1",
-		"eslint-config-prettier": "^8.10.2",
-		"eslint-import-resolver-typescript": "^3.10.1",
+		"eslint": "^9.0.0",
+		"eslint-import-resolver-typescript": "^4.4.4",
 		"eslint-plugin-import": "^2.32.0",
 		"eslint-plugin-playwright": "^2.10.2",
 		"eslint-plugin-react": "^7.37.5",
 		"eslint-plugin-react-hooks": "^7.1.1",
-		"globals": "^13.24.0",
+		"globals": "^17.6.0",
 		"prettier": "^3.8.1",
 		"stylelint": "^16.26.1",
 		"stylelint-config-standard": "^39.0.1",
 		"stylelint-config-standard-scss": "^16.0.0",
 		"stylelint-no-restricted-syntax": "^2.2.1",
 		"stylelint-order": "^7.0.1",
-		"typescript-eslint": "^8.50.0"
+		"typescript-eslint": "^8.59.3"
 	},
 	"keywords": [
 		"atomic",
@@ -50,5 +78,14 @@
 	},
 	"publishConfig": {
 		"access": "public"
+	},
+	"scripts": {
+		"dev": "tsc --build --watch tsconfig.build.json",
+		"build": "npm-run-all clean compile",
+		"clean": "del-cli ./dist/ *.tsbuildinfo",
+		"compile": "tsc --build tsconfig.build.json",
+		"lint": "run-p lint:*",
+		"lint:eslint": "eslint --cache --cache-location ./node_modules/.cache/eslint . --ext .js,.ts,.jsx,.tsx",
+		"lint:types": "tsc"
 	}
 }

package/typescript/base.json

@@ -16,6 +16,7 @@
 		"checkJs": true,
 		"forceConsistentCasingInFileNames": true,
 		"verbatimModuleSyntax": true,
-		"noImplicitOverride": true
+		"noImplicitOverride": true,
+		"strictNullChecks": true
 	}
 }

package/typescript/cypress.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "http://json.schemastore.org/tsconfig",
+	"$schema": "https://json.schemastore.org/tsconfig",
 	"exclude": [
 		"../node_modules/@types/jest",
 		"../node_modules/@testing-library/jest-dom"

package/.eslintrc.cjs

@@ -1,8 +0,0 @@
-/** @type {import('eslint').Linter.Config} */
-module.exports = {
-	extends: ["@atomicsmash/eslint-config"],
-	parserOptions: {
-		sourceType: "module",
-	},
-	ignorePatterns: ["**/*.d.ts"],
-};

package/beta/README.md

@@ -1,3 +0,0 @@
-# Beta files
-
-Config files added to this folder are not stable. They are added here to avoid keeping a separate branch up to date with other configs, and also enable multiple beta configs in a single project.