@plumeria/eslint-plugin 18.3.17 → 18.4.0

package/dist/rules/expand-border-shorthands.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandBorderShorthands = void 0;
 const borderShorthand_1 = require("../util/borderShorthand");
-const logicalPhysical_1 = require("../util/logicalPhysical");
+const zss_engine_1 = require("zss-engine");
 const styleObject_1 = require("../util/styleObject");
 const BUNDLES = new Set(borderShorthand_1.BORDER_BUNDLES);
 exports.expandBorderShorthands = {
@@ -96,7 +96,7 @@ exports.expandBorderShorthands = {
                     typeof prop.key.value === 'string') {
                     name = prop.key.value;
                 }
-                const kebab = (0, logicalPhysical_1.toKebabCase)(name);
+                const kebab = (0, zss_engine_1.camelToKebabCase)(name);
                 if (!BUNDLES.has(kebab))
                     return;
                 let literal = null;
@@ -142,7 +142,7 @@ exports.expandBorderShorthands = {
                 };
                 const indent = ' '.repeat(prop.loc.start.column);
                 const declarations = ['width', 'style', 'color']
-                    .map((part) => `${(0, logicalPhysical_1.toCamelCase)(`${kebab}-${part}`)}: ${render(parts[part])}`)
+                    .map((part) => `${(0, zss_engine_1.kebabToCamelCase)(`${kebab}-${part}`)}: ${render(parts[part])}`)
                     .join(`,\n${indent}`);
                 context.report({
                     node: prop.key,

package/dist/rules/no-order-dependent-overlap.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noOrderDependentOverlap = void 0;
 const zss_engine_1 = require("zss-engine");
-const logicalPhysical_1 = require("../util/logicalPhysical");
 const selector_1 = require("../util/selector");
 const styleObject_1 = require("../util/styleObject");
 const DIRECT_SHORTHANDS = {};
@@ -34,12 +33,12 @@ const coverageOf = (property) => {
     const longhands = zss_engine_1.DIRECT_LONGHANDS[property];
     const coverage = longhands
         ? new Set(longhands.flatMap((longhand) => [...coverageOf(longhand)]))
-        : new Set([(0, logicalPhysical_1.canonicalProperty)(property)]);
+        : new Set([(0, zss_engine_1.canonicalProperty)(property)]);
     coverages.set(property, coverage);
     return coverage;
 };
 const overlapOf = (first, second) => {
-    if ((0, logicalPhysical_1.canonicalProperty)(first) === (0, logicalPhysical_1.canonicalProperty)(second))
+    if ((0, zss_engine_1.canonicalProperty)(first) === (0, zss_engine_1.canonicalProperty)(second))
         return 'alias';
     const left = coverageOf(first);
     const right = coverageOf(second);
@@ -157,9 +156,10 @@ exports.noOrderDependentOverlap = {
             if (first.startsWith('--') || second.startsWith('--')) {
                 return first === second;
             }
-            return ((0, logicalPhysical_1.canonicalProperty)((0, logicalPhysical_1.toKebabCase)(first)) ===
-                (0, logicalPhysical_1.canonicalProperty)((0, logicalPhysical_1.toKebabCase)(second)) ||
-                overlapOf((0, logicalPhysical_1.toKebabCase)(first), (0, logicalPhysical_1.toKebabCase)(second)) === 'crossing');
+            return ((0, zss_engine_1.canonicalProperty)((0, zss_engine_1.camelToKebabCase)(first)) ===
+                (0, zss_engine_1.canonicalProperty)((0, zss_engine_1.camelToKebabCase)(second)) ||
+                overlapOf((0, zss_engine_1.camelToKebabCase)(first), (0, zss_engine_1.camelToKebabCase)(second)) ===
+                    'crossing');
         }
         function swapProperties(fixer, first, second) {
             return [
@@ -212,7 +212,7 @@ exports.noOrderDependentOverlap = {
                     name.startsWith('--')) {
                     return;
                 }
-                declarations.push({ prop, name, kebab: (0, logicalPhysical_1.toKebabCase)(name) });
+                declarations.push({ prop, name, kebab: (0, zss_engine_1.camelToKebabCase)(name) });
             });
             for (let i = 0; i < conditions.length; i++) {
                 for (let j = i + 1; j < conditions.length; j++) {

package/dist/rules/no-unknown-css-properties.js

@@ -2,17 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnknownCssProperties = void 0;
 const known_css_properties_1 = require("known-css-properties");
+const zss_engine_1 = require("zss-engine");
 const styleObject_1 = require("../util/styleObject");
 const knownProperties = new Set(known_css_properties_1.all);
-const kebabCache = new Map();
-function toKebabCase(str) {
-    if (kebabCache.has(str)) {
-        return kebabCache.get(str);
-    }
-    const result = str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-    kebabCache.set(str, result);
-    return result;
-}
 exports.noUnknownCssProperties = {
     meta: {
         type: 'problem',
@@ -107,7 +99,7 @@ exports.noUnknownCssProperties = {
                             !keyName.startsWith('[') &&
                             !keyName.startsWith('@') &&
                             !keyName.startsWith('--')) {
-                            const kebabName = toKebabCase(keyName);
+                            const kebabName = (0, zss_engine_1.camelToKebabCase)(keyName);
                             if (!knownProperties.has(kebabName)) {
                                 context.report({
                                     node: prop.key,

package/dist/util/spellingRule.d.ts

@@ -1,3 +1,3 @@
-import type { PropertySpelling } from './logicalPhysical';
+import type { PropertySpelling } from 'zss-engine';
 import type { Rule } from 'eslint';
 export declare const createSpellingRule: (reject: PropertySpelling) => Rule.RuleModule;

package/dist/util/spellingRule.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSpellingRule = void 0;
-const logicalPhysical_1 = require("./logicalPhysical");
+const zss_engine_1 = require("zss-engine");
 const styleObject_1 = require("./styleObject");
 const DESCRIPTIONS = {
     physical: 'Disallow the physical name of a property that also has a logical name',
@@ -110,10 +110,10 @@ const createSpellingRule = (reject) => ({
                 }
                 if (!name)
                     return;
-                const kebab = (0, logicalPhysical_1.toKebabCase)(name);
-                if ((0, logicalPhysical_1.spellingOf)(kebab, includeAxes) !== reject)
+                const kebab = (0, zss_engine_1.camelToKebabCase)(name);
+                if ((0, zss_engine_1.spellingOf)(kebab, includeAxes) !== reject)
                     return;
-                report(prop, name, (0, logicalPhysical_1.toCamelCase)((0, logicalPhysical_1.counterpartOf)(kebab)));
+                report(prop, name, (0, zss_engine_1.kebabToCamelCase)((0, zss_engine_1.counterpartOf)(kebab)));
             });
         }
         function report(prop, name, counterpart) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/eslint-plugin",
-  "version": "18.3.17",
+  "version": "18.4.0",
   "description": "Plumeria ESLint plugin",
   "author": "Refirst 11",
   "license": "MIT",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "^8.60.0",
     "known-css-properties": "^0.37.0",
-    "zss-engine": "2.7.0"
+    "zss-engine": "2.8.0"
   },
   "scripts": {
     "build": "rimraf dist && pnpm cjs",

package/dist/util/logicalPhysical.d.ts

@@ -1,9 +0,0 @@
-export declare const LOGICAL_PHYSICAL_EDGES: [string, string][];
-export declare const LOGICAL_PHYSICAL_AXES: [string, string][];
-export declare const LOGICAL_PHYSICAL_PAIRS: [string, string][];
-export type PropertySpelling = 'logical' | 'physical';
-export declare const canonicalProperty: (property: string) => string;
-export declare const counterpartOf: (property: string) => string | undefined;
-export declare const spellingOf: (property: string, includeAxes: boolean) => PropertySpelling | undefined;
-export declare const toKebabCase: (name: string) => string;
-export declare const toCamelCase: (name: string) => string;

package/dist/util/logicalPhysical.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCamelCase = exports.toKebabCase = exports.spellingOf = exports.counterpartOf = exports.canonicalProperty = exports.LOGICAL_PHYSICAL_PAIRS = exports.LOGICAL_PHYSICAL_AXES = exports.LOGICAL_PHYSICAL_EDGES = void 0;
-exports.LOGICAL_PHYSICAL_EDGES = [
-    ['margin-block-start', 'margin-top'],
-    ['margin-block-end', 'margin-bottom'],
-    ['margin-inline-start', 'margin-left'],
-    ['margin-inline-end', 'margin-right'],
-    ['padding-block-start', 'padding-top'],
-    ['padding-block-end', 'padding-bottom'],
-    ['padding-inline-start', 'padding-left'],
-    ['padding-inline-end', 'padding-right'],
-    ['scroll-margin-block-start', 'scroll-margin-top'],
-    ['scroll-margin-block-end', 'scroll-margin-bottom'],
-    ['scroll-margin-inline-start', 'scroll-margin-left'],
-    ['scroll-margin-inline-end', 'scroll-margin-right'],
-    ['scroll-padding-block-start', 'scroll-padding-top'],
-    ['scroll-padding-block-end', 'scroll-padding-bottom'],
-    ['scroll-padding-inline-start', 'scroll-padding-left'],
-    ['scroll-padding-inline-end', 'scroll-padding-right'],
-    ['inset-block-start', 'top'],
-    ['inset-block-end', 'bottom'],
-    ['inset-inline-start', 'left'],
-    ['inset-inline-end', 'right'],
-    ['border-block-start', 'border-top'],
-    ['border-block-end', 'border-bottom'],
-    ['border-inline-start', 'border-left'],
-    ['border-inline-end', 'border-right'],
-    ['border-block-start-width', 'border-top-width'],
-    ['border-block-start-style', 'border-top-style'],
-    ['border-block-start-color', 'border-top-color'],
-    ['border-block-end-width', 'border-bottom-width'],
-    ['border-block-end-style', 'border-bottom-style'],
-    ['border-block-end-color', 'border-bottom-color'],
-    ['border-inline-start-width', 'border-left-width'],
-    ['border-inline-start-style', 'border-left-style'],
-    ['border-inline-start-color', 'border-left-color'],
-    ['border-inline-end-width', 'border-right-width'],
-    ['border-inline-end-style', 'border-right-style'],
-    ['border-inline-end-color', 'border-right-color'],
-    ['border-start-start-radius', 'border-top-left-radius'],
-    ['border-start-end-radius', 'border-top-right-radius'],
-    ['border-end-start-radius', 'border-bottom-left-radius'],
-    ['border-end-end-radius', 'border-bottom-right-radius'],
-    ['corner-start-start-shape', 'corner-top-left-shape'],
-    ['corner-start-end-shape', 'corner-top-right-shape'],
-    ['corner-end-start-shape', 'corner-bottom-left-shape'],
-    ['corner-end-end-shape', 'corner-bottom-right-shape'],
-];
-exports.LOGICAL_PHYSICAL_AXES = [
-    ['block-size', 'height'],
-    ['inline-size', 'width'],
-    ['min-block-size', 'min-height'],
-    ['min-inline-size', 'min-width'],
-    ['max-block-size', 'max-height'],
-    ['max-inline-size', 'max-width'],
-    ['overflow-block', 'overflow-y'],
-    ['overflow-inline', 'overflow-x'],
-    ['overscroll-behavior-block', 'overscroll-behavior-y'],
-    ['overscroll-behavior-inline', 'overscroll-behavior-x'],
-    ['contain-intrinsic-block-size', 'contain-intrinsic-height'],
-    ['contain-intrinsic-inline-size', 'contain-intrinsic-width'],
-];
-exports.LOGICAL_PHYSICAL_PAIRS = [
-    ...exports.LOGICAL_PHYSICAL_EDGES,
-    ...exports.LOGICAL_PHYSICAL_AXES,
-];
-const PHYSICAL_OF_LOGICAL = new Map(exports.LOGICAL_PHYSICAL_PAIRS);
-const LOGICAL_OF_PHYSICAL = new Map(exports.LOGICAL_PHYSICAL_PAIRS.map(([logical, physical]) => [physical, logical]));
-const canonicalProperty = (property) => PHYSICAL_OF_LOGICAL.get(property) ?? property;
-exports.canonicalProperty = canonicalProperty;
-const counterpartOf = (property) => PHYSICAL_OF_LOGICAL.get(property) ?? LOGICAL_OF_PHYSICAL.get(property);
-exports.counterpartOf = counterpartOf;
-const spellingOf = (property, includeAxes) => {
-    const table = includeAxes ? exports.LOGICAL_PHYSICAL_PAIRS : exports.LOGICAL_PHYSICAL_EDGES;
-    for (const [logical, physical] of table) {
-        if (property === logical)
-            return 'logical';
-        if (property === physical)
-            return 'physical';
-    }
-    return undefined;
-};
-exports.spellingOf = spellingOf;
-const kebabCache = new Map();
-const toKebabCase = (name) => {
-    const cached = kebabCache.get(name);
-    if (cached !== undefined)
-        return cached;
-    const kebab = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-    kebabCache.set(name, kebab);
-    return kebab;
-};
-exports.toKebabCase = toKebabCase;
-const toCamelCase = (name) => name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-exports.toCamelCase = toCamelCase;