stylelint-logical-spec 6.0.0

package/LICENSE.md

@@ -0,0 +1,108 @@
+# CC0 1.0 Universal
+
+## Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an “owner”) of an original work of
+authorship and/or a database (each, a “Work”).
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific works
+(“Commons”) that the public can reliably and without fear of later claims of
+infringement build upon, modify, incorporate in other works, reuse and
+redistribute as freely as possible in any form whatsoever and for any purposes,
+including without limitation commercial purposes. These owners may contribute
+to the Commons to promote the ideal of a free culture and the further
+production of creative, cultural and scientific works, or to gain reputation or
+greater distribution for their Work in part through the use and efforts of
+others.
+
+For these and/or other purposes and motivations, and without any expectation of
+additional consideration or compensation, the person associating CC0 with a
+Work (the “Affirmer”), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and
+publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+   protected by copyright and related or neighboring rights (“Copyright and
+   Related Rights”). Copyright and Related Rights include, but are not limited
+   to, the following:
+   1. the right to reproduce, adapt, distribute, perform, display, communicate,
+      and translate a Work;
+   2. moral rights retained by the original author(s) and/or performer(s);
+   3. publicity and privacy rights pertaining to a person’s image or likeness
+      depicted in a Work;
+   4. rights protecting against unfair competition in regards to a Work,
+      subject to the limitations in paragraph 4(i), below;
+   5. rights protecting the extraction, dissemination, use and reuse of data in
+      a Work;
+   6. database rights (such as those arising under Directive 96/9/EC of the
+      European Parliament and of the Council of 11 March 1996 on the legal
+      protection of databases, and under any national implementation thereof,
+      including any amended or successor version of such directive); and
+   7. other similar, equivalent or corresponding rights throughout the world
+      based on applicable law or treaty, and any national implementations
+      thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+   applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+   unconditionally waives, abandons, and surrenders all of Affirmer’s Copyright
+   and Related Rights and associated claims and causes of action, whether now
+   known or unknown (including existing as well as future claims and causes of
+   action), in the Work (i) in all territories worldwide, (ii) for the maximum
+   duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number of
+   copies, and (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the “Waiver”). Affirmer
+   makes the Waiver for the benefit of each member of the public at large and
+   to the detriment of Affirmer’s heirs and successors, fully intending that
+   such Waiver shall not be subject to revocation, rescission, cancellation,
+   termination, or any other legal or equitable action to disrupt the quiet
+   enjoyment of the Work by the public as contemplated by Affirmer’s express
+   Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+   judged legally invalid or ineffective under applicable law, then the Waiver
+   shall be preserved to the maximum extent permitted taking into account
+   Affirmer’s express Statement of Purpose. In addition, to the extent the
+   Waiver is so judged Affirmer hereby grants to each affected person a
+   royalty-free, non transferable, non sublicensable, non exclusive,
+   irrevocable and unconditional license to exercise Affirmer’s Copyright and
+   Related Rights in the Work (i) in all territories worldwide, (ii) for the
+   maximum duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number of
+   copies, and (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the “License”). The License
+   shall be deemed effective as of the date CC0 was applied by Affirmer to the
+   Work. Should any part of the License for any reason be judged legally
+   invalid or ineffective under applicable law, such partial invalidity or
+   ineffectiveness shall not invalidate the remainder of the License, and in
+   such case Affirmer hereby affirms that he or she will not (i) exercise any
+   of his or her remaining Copyright and Related Rights in the Work or (ii)
+   assert any associated claims and causes of action with respect to the Work,
+   in either case contrary to Affirmer’s express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+   1. No trademark or patent rights held by Affirmer are waived, abandoned,
+      surrendered, licensed or otherwise affected by this document.
+   2. Affirmer offers the Work as-is and makes no representations or warranties
+      of any kind concerning the Work, express, implied, statutory or
+      otherwise, including without limitation warranties of title,
+      merchantability, fitness for a particular purpose, non infringement, or
+      the absence of latent or other defects, accuracy, or the present or
+      absence of errors, whether or not discoverable, all to the greatest
+      extent permissible under applicable law.
+   3. Affirmer disclaims responsibility for clearing rights of other persons
+      that may apply to the Work or any use thereof, including without
+      limitation any person’s Copyright and Related Rights in the Work.
+      Further, Affirmer disclaims responsibility for obtaining any necessary
+      consents, permissions or other rights required for any use of the Work.
+   4. Affirmer understands and acknowledges that Creative Commons is not a
+      party to this document and has no duty or obligation with respect to this
+      CC0 or use of the Work.
+
+For more information, please see
+http://creativecommons.org/publicdomain/zero/1.0/.

package/README.md

@@ -0,0 +1,55 @@
+# stylelint-logical-spec
+
+A stylelint plugin to enforce the use of logical properties and values instead of physical ones.
+
+> [!NOTE]
+> This project is a fork of [`Jordan-Hall/stylelint-use-logical-spec`](https://github.com/Jordan-Hall/stylelint-use-logical-spec) (originally inspired by `csstools/stylelint-use-logical`). 
+> 
+> **Why this fork exists:**
+> - **Modernization**: Full migration to TypeScript for better type safety and developer experience.
+> - **Compatibility**: Support for Stylelint 16 and 17+.
+> - **Standardization**: Converted to a native ES Module (ESM) and modernized testing infrastructure.
+
+## Installation
+
+```bash
+npm install stylelint-logical-spec --save-dev
+```
+
+## Usage
+
+Add it to your stylelint configuration:
+
+```json
+{
+  "plugins": ["stylelint-logical-spec"],
+  "rules": {
+    "liberty/use-logical-spec": true
+  }
+}
+```
+
+## Rules
+
+### `liberty/use-logical-spec`
+
+Enforces logical properties and values like `margin-block-start` instead of physical ones like `margin-top`.
+
+#### Options
+
+- `direction`: `ltr` (default) or `rtl`. Controls the mapping of physical properties to logical ones.
+- `except`: An array of properties or regex patterns to ignore.
+
+```json
+{
+  "rules": {
+    "liberty/use-logical-spec": [true, { "direction": "rtl", "except": ["top"] }]
+  }
+}
+```
+
+Supports auto-fixing with `--fix`.
+
+## License
+
+[CC0-1.0](LICENSE.md)

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import stylelint from 'stylelint';
+import ruleName from './lib/rule-name.js';
+import messages from './lib/messages.js';
+export { ruleName, messages };
+declare const _default: stylelint.Plugin;
+export default _default;

package/dist/index.js

@@ -0,0 +1,315 @@
+import stylelint from 'stylelint';
+import { physicalProp, physical2Prop, physicalShorthandProp, physical4Prop, physicalValue, migrationNoneSpec, propsThatContainPropsInValue } from './lib/maps.js';
+import { validateRuleWithProps } from './lib/validate.js';
+import { cssValueSplit } from './lib/value-split.js';
+import ruleName from './lib/rule-name.js';
+import messages from './lib/messages.js';
+import walk from './lib/walk.js';
+const reportedDecls = new WeakMap();
+// Ignore autofix on those expression value
+const expressionRegex = /^\$\{.*\}$/g;
+const ruleFunction = (primary, secondaryOptions = {}, _context = {}) => {
+    const propExceptions = [].concat(secondaryOptions.except || []);
+    const dir = /^rtl$/i.test(secondaryOptions.direction || '') ? 'rtl' : 'ltr';
+    const physicalProps = physicalProp(dir);
+    const physical2Props = physical2Prop(dir);
+    const physicalValues = physicalValue(dir);
+    // Pre-compile regex for performance
+    const propRegexMap = new Map();
+    physicalProps.forEach(([props]) => {
+        props.forEach(searchProp => {
+            if (!propRegexMap.has(searchProp)) {
+                propRegexMap.set(searchProp, new RegExp("(?<!-)" + searchProp + "(?!-)", "g"));
+            }
+        });
+    });
+    return (root, result) => {
+        // validate the method
+        const isMethodValid = stylelint.utils.validateOptions(result, ruleName, {
+            actual: primary,
+            possible() {
+                return isMethodIndifferent(primary) ||
+                    isMethodAlways(primary);
+            }
+        });
+        if (!isMethodValid || !isMethodAlways(primary)) {
+            return;
+        }
+        walk(root, node => {
+            migrationNoneSpec.forEach(([prop, props]) => {
+                validateRuleWithProps(node, prop, (...args) => {
+                    const outDateDecl = args[0];
+                    if (isDeclReported(outDateDecl))
+                        return;
+                    stylelint.utils.report({
+                        message: messages.unsupportedProp(outDateDecl.prop, props),
+                        node: outDateDecl,
+                        result,
+                        ruleName,
+                        fix: () => {
+                            if (expressionRegex.test(outDateDecl.value))
+                                return;
+                            const value = outDateDecl.value;
+                            outDateDecl.cloneBefore({
+                                prop: props[0],
+                                value
+                            });
+                            outDateDecl.cloneAfter({
+                                prop: props[1],
+                                value
+                            });
+                            outDateDecl.remove();
+                        }
+                    });
+                    reportedDecls.set(outDateDecl, true);
+                });
+            });
+            /* logical shorthands do not work yet in browsers */
+            /* but we can still use shorthand if all values are the same */
+            // validate or autofix 4 physical properties as logical shorthands
+            physical4Prop.forEach(([props, prop]) => {
+                validateRuleWithProps(node, props, (...args) => {
+                    const blockStartDecl = args[0];
+                    const inlineStartDecl = args[2];
+                    const blockEndDecl = args[4];
+                    const inlineEndDecl = args[6];
+                    if (isDeclReported(blockStartDecl) || isDeclReported(inlineStartDecl) || isDeclReported(blockEndDecl) || isDeclReported(inlineEndDecl))
+                        return;
+                    const values = shorthandValueShorten([blockStartDecl.value, inlineStartDecl.value, blockEndDecl.value, inlineEndDecl.value]);
+                    if (!isDeclAnException(blockStartDecl, propExceptions) &&
+                        !isDeclAnException(inlineStartDecl, propExceptions) &&
+                        !isDeclAnException(blockEndDecl, propExceptions) &&
+                        !isDeclAnException(inlineEndDecl, propExceptions) &&
+                        values.length === 1 // only report issues if there is 1 value after shortening
+                    ) {
+                        stylelint.utils.report({
+                            message: messages.unexpectedProp(blockStartDecl.prop, prop),
+                            node: blockStartDecl,
+                            result,
+                            ruleName,
+                            fix: () => {
+                                if (expressionRegex.test(blockStartDecl.value))
+                                    return;
+                                blockStartDecl.cloneBefore({
+                                    prop,
+                                    value: values.join(' ')
+                                });
+                                blockStartDecl.remove();
+                                inlineStartDecl.remove();
+                                blockEndDecl.remove();
+                                inlineEndDecl.remove();
+                            }
+                        });
+                        reportedDecls.set(blockStartDecl, true);
+                        reportedDecls.set(inlineStartDecl, true);
+                        reportedDecls.set(blockEndDecl, true);
+                        reportedDecls.set(inlineEndDecl, true);
+                    }
+                });
+            });
+            // validate or autofix shorthand properties that are not supported
+            physicalShorthandProp.forEach((prop) => {
+                validateRuleWithProps(node, [prop], (...args) => {
+                    const physicalDecl = args[0];
+                    if (isDeclReported(physicalDecl))
+                        return;
+                    const inputValues = cssValueSplit(physicalDecl.value);
+                    if (!isDeclAnException(physicalDecl, propExceptions) &&
+                        inputValues.length !== 1) {
+                        stylelint.utils.report({
+                            message: messages.unexpectedProp(physicalDecl.prop, `${prop}-block and ${prop}-inline`),
+                            node: physicalDecl,
+                            result,
+                            ruleName,
+                            fix: () => {
+                                if (expressionRegex.test(physicalDecl.value))
+                                    return;
+                                let outputValues = convertShorthandValues(inputValues, dir);
+                                ['block', 'inline'].forEach(type => {
+                                    physicalDecl.cloneBefore({
+                                        prop: prop + "-" + type,
+                                        value: outputValues[type]
+                                    });
+                                });
+                                physicalDecl.remove();
+                            }
+                        });
+                        reportedDecls.set(physicalDecl, true);
+                    }
+                });
+            });
+            // validate or autofix 2 physical properties as logical shorthands
+            physical2Props.forEach(([props, prop]) => {
+                validateRuleWithProps(node, props, (...args) => {
+                    const startDecl = args[0];
+                    const startIndex = args[1];
+                    const endDecl = args[2];
+                    const endStartIndex = args[3];
+                    if (isDeclReported(startDecl) || isDeclReported(endDecl))
+                        return;
+                    const firstInlineDecl = startIndex < endStartIndex
+                        ? startDecl
+                        : endDecl;
+                    if (!isDeclAnException(startDecl, propExceptions) && !isDeclAnException(endDecl, propExceptions)) {
+                        stylelint.utils.report({
+                            message: messages.unexpectedProp(firstInlineDecl.prop, prop),
+                            node: firstInlineDecl,
+                            result,
+                            ruleName,
+                            fix: () => {
+                                if (expressionRegex.test(startDecl.value))
+                                    return;
+                                firstInlineDecl.cloneBefore({
+                                    prop,
+                                    value: startDecl.value === endDecl.value
+                                        ? startDecl.value
+                                        : [startDecl.value, endDecl.value].join(' ')
+                                });
+                                startDecl.remove();
+                                endDecl.remove();
+                            }
+                        });
+                        reportedDecls.set(startDecl, true);
+                        reportedDecls.set(endDecl, true);
+                    }
+                });
+            });
+            // validate or autofix physical properties as logical
+            physicalProps.forEach(([props, prop]) => {
+                validateRuleWithProps(node, props, (...args) => {
+                    const physicalDecl = args[0];
+                    if (isDeclReported(physicalDecl))
+                        return;
+                    if (!isDeclAnException(physicalDecl, propExceptions)) {
+                        stylelint.utils.report({
+                            message: messages.unexpectedProp(physicalDecl.prop, prop),
+                            node: physicalDecl,
+                            result,
+                            ruleName,
+                            fix: () => {
+                                if (expressionRegex.test(physicalDecl.value))
+                                    return;
+                                physicalDecl.prop = prop;
+                            }
+                        });
+                        reportedDecls.set(physicalDecl, true);
+                    }
+                });
+            });
+            // validate or autofix physical values as logical
+            physicalValues.forEach(([regexp, props]) => {
+                const decl = node;
+                if (isNodeMatchingDecl(decl, regexp) && !isDeclAnException(decl, propExceptions)) {
+                    if (isDeclReported(decl))
+                        return;
+                    const valuekey = decl.value.toLowerCase();
+                    if (valuekey in props) {
+                        const value = props[valuekey];
+                        stylelint.utils.report({
+                            message: messages.unexpectedValue(decl.prop, decl.value, value),
+                            node: decl,
+                            result,
+                            ruleName,
+                            fix: () => {
+                                if (expressionRegex.test(decl.value))
+                                    return;
+                                decl.value = value;
+                            }
+                        });
+                        reportedDecls.set(decl, true);
+                    }
+                }
+            });
+            // validate or autofix physical values containing properties as logical
+            if (isNodeMatchingDecl(node, propsThatContainPropsInValue)) {
+                const decl = node;
+                if (isDeclReported(decl))
+                    return;
+                const originalValue = decl.value.toLowerCase();
+                let value = originalValue;
+                physicalProps.forEach(([props, prop]) => {
+                    if (!isDeclAnException(decl, propExceptions)) {
+                        props.forEach(searchProp => {
+                            if (!isValueAnException(searchProp, propExceptions)) {
+                                const regex = propRegexMap.get(searchProp);
+                                if (regex && regex.test(value)) {
+                                    value = value.replace(regex, prop);
+                                }
+                            }
+                        });
+                    }
+                });
+                if (value !== originalValue) {
+                    stylelint.utils.report({
+                        message: messages.unexpectedValue(decl.prop, decl.value, value),
+                        node: decl,
+                        result,
+                        ruleName,
+                        fix: () => {
+                            if (expressionRegex.test(decl.value))
+                                return;
+                            decl.value = value;
+                        }
+                    });
+                    reportedDecls.set(decl, true);
+                }
+            }
+        });
+    };
+};
+ruleFunction.ruleName = ruleName;
+ruleFunction.messages = messages;
+ruleFunction.meta = {
+    url: 'https://github.com/bleeding-gums/stylelint-logical-spec',
+    fixable: true,
+};
+export { ruleName, messages };
+export default stylelint.createPlugin(ruleName, ruleFunction);
+const isMethodIndifferent = (method) => method === 'ignore' || method === false || method === null;
+const isMethodAlways = (method) => method === 'always' || method === true;
+const isNodeMatchingDecl = (decl, regexp) => decl.type === 'decl' && regexp.test(decl.prop);
+const isDeclAnException = (decl, propExceptions) => isValueAnException(decl.prop, propExceptions);
+const isValueAnException = (value, propExceptions) => propExceptions.some(match => match instanceof RegExp
+    ? match.test(value)
+    : String(match || '').toLowerCase() === String(value || '').toLowerCase());
+const isDeclReported = (decl) => reportedDecls.has(decl);
+const shorthandValueShorten = (values) => {
+    const map = [[1, 0], [0, 2], [1, 3]];
+    for (let x = values.length - 2; x >= 0; x--) {
+        if (values[map[x][0]] !== values[map[x][1]]) {
+            break;
+        }
+        values.pop();
+    }
+    return values;
+};
+const convertShorthandValues = (input, dir) => {
+    let block = '', inline = '';
+    if (input.length === 1) {
+        block = input[0];
+        inline = input[0];
+    }
+    if (input.length === 2) {
+        block = input[0];
+        inline = input[1];
+    }
+    if (input.length === 3) {
+        block = input[0] + ' ' + input[2];
+        inline = input[1];
+    }
+    if (input.length === 4) {
+        block = input[0] + ' ' + input[2];
+        inline = dir === 'ltr' ? input[3] + ' ' + input[1] : input[1] + ' ' + input[3];
+    }
+    return {
+        block: optimizeCssValues(block),
+        inline: optimizeCssValues(inline)
+    };
+};
+const optimizeCssValues = (value) => {
+    const values = cssValueSplit(value);
+    if (values.length === 2 && values[0] === values[1]) {
+        return values[0];
+    }
+    return value;
+};

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/maps.d.ts

@@ -0,0 +1,8 @@
+export type Direction = 'ltr' | 'rtl';
+export declare const propsThatContainPropsInValue: RegExp;
+export declare const physical4Prop: readonly (readonly [readonly string[], string])[];
+export declare const physicalShorthandProp: readonly string[];
+export declare const physical2Prop: (dir: Direction) => readonly (readonly [readonly string[], string])[];
+export declare const physicalProp: (dir: Direction) => readonly (readonly [readonly string[], string])[];
+export declare const physicalValue: (dir: Direction) => readonly (readonly [RegExp, Record<string, string>])[];
+export declare const migrationNoneSpec: readonly (readonly [readonly string[], readonly string[]])[];

package/dist/lib/maps.js

@@ -0,0 +1,82 @@
+const inline = {
+    start: { ltr: 'left', rtl: 'right' },
+    end: { ltr: 'right', rtl: 'left' }
+};
+export const propsThatContainPropsInValue = /^(transition(-property)?|will-change)$/i;
+export const physical4Prop = [
+    [['top', 'left', 'bottom', 'right'], 'inset'],
+    [['margin-top', 'margin-left', 'margin-bottom', 'margin-right'], 'margin'],
+    [['padding-top', 'padding-left', 'padding-bottom', 'padding-right'], 'padding']
+];
+export const physicalShorthandProp = ['inset', 'margin', 'padding'];
+export const physical2Prop = (dir) => [
+    [['top', 'bottom'], 'inset-block'],
+    [[inline.start[dir], inline.end[dir]], 'inset-inline'],
+    [['margin-top', 'margin-bottom'], 'margin-block'],
+    [[`margin-${inline.start[dir]}`, `margin-${inline.end[dir]}`], 'margin-inline'],
+    [['padding-top', 'padding-bottom'], 'padding-block'],
+    [[`padding-${inline.start[dir]}`, `padding-${inline.end[dir]}`], 'padding-inline'],
+];
+export const physicalProp = (dir) => [
+    [['top'], 'inset-block-start'],
+    [['bottom'], 'inset-block-end'],
+    [[inline.start[dir]], 'inset-inline-start'],
+    [[inline.end[dir]], 'inset-inline-end'],
+    [['margin-top'], 'margin-block-start'],
+    [['margin-bottom'], 'margin-block-end'],
+    [[`margin-${inline.start[dir]}`], 'margin-inline-start'],
+    [[`margin-${inline.end[dir]}`], 'margin-inline-end'],
+    [['padding-top'], 'padding-block-start'],
+    [['padding-bottom'], 'padding-block-end'],
+    [[`padding-${inline.start[dir]}`], 'padding-inline-start'],
+    [[`padding-${inline.end[dir]}`], 'padding-inline-end'],
+    // border
+    [['border-top'], 'border-block-start'],
+    [['border-bottom'], 'border-block-end'],
+    [[`border-${inline.start[dir]}`], 'border-inline-start'],
+    [[`border-${inline.end[dir]}`], 'border-inline-end'],
+    [['border-top-color'], 'border-block-start-color'],
+    [['border-top-style'], 'border-block-start-style'],
+    [['border-top-width'], 'border-block-start-width'],
+    [['border-bottom-color'], 'border-block-end-color'],
+    [['border-bottom-style'], 'border-block-end-style'],
+    [['border-bottom-width'], 'border-block-end-width'],
+    [[`border-${inline.start[dir]}-color`], 'border-inline-start-color'],
+    [[`border-${inline.start[dir]}-style`], 'border-inline-start-style'],
+    [[`border-${inline.start[dir]}-width`], 'border-inline-start-width'],
+    [[`border-${inline.end[dir]}-color`], 'border-inline-end-color'],
+    [[`border-${inline.end[dir]}-style`], 'border-inline-end-style'],
+    [[`border-${inline.end[dir]}-width`], 'border-inline-end-width'],
+    [[`border-top-${inline.start[dir]}-radius`], 'border-start-start-radius'],
+    [[`border-bottom-${inline.start[dir]}-radius`], 'border-end-start-radius'],
+    [[`border-top-${inline.end[dir]}-radius`], 'border-start-end-radius'],
+    [[`border-bottom-${inline.end[dir]}-radius`], 'border-end-end-radius'],
+    [['height'], 'block-size'],
+    [['min-height'], 'min-block-size'],
+    [['max-height'], 'max-block-size'],
+    [['width'], 'inline-size'],
+    [['min-width'], 'min-inline-size'],
+    [['max-width'], 'max-inline-size'],
+];
+export const physicalValue = (dir) => [
+    [/^clear$/i, {
+            [inline.start[dir]]: 'inline-start',
+            [inline.end[dir]]: 'inline-end'
+        }],
+    [/^float$/i, {
+            [inline.start[dir]]: 'inline-start',
+            [inline.end[dir]]: 'inline-end'
+        }],
+    [/^text-align$/i, {
+            [inline.start[dir]]: 'start',
+            [inline.end[dir]]: 'end'
+        }]
+];
+export const migrationNoneSpec = [
+    [['margin-start'], ['margin-block-start', 'margin-inline-start']],
+    [['margin-end'], ['margin-block-end', 'margin-inline-end']],
+    [['padding-start'], ['padding-block-start', 'padding-inline-start']],
+    [['padding-end'], ['padding-block-end', 'padding-inline-end']],
+    [['inset-start'], ['inset-inline-start', 'inset-block-start']],
+    [['inset-end'], ['inset-inline-end', 'inset-block-end']],
+];

package/dist/lib/messages.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    unexpectedProp: (physicalProperty: string, logicalProperty: string) => string;
+    unexpectedValue: (property: string, physicalValue: string, logicalValue: string) => string;
+    unsupportedProp: (physicalProperty: string, logicalProperty: [string, string]) => string;
+};
+export default _default;

package/dist/lib/messages.js

@@ -0,0 +1,13 @@
+import stylelint from 'stylelint';
+import ruleName from './rule-name.js';
+export default stylelint.utils.ruleMessages(ruleName, {
+    unexpectedProp(physicalProperty, logicalProperty) {
+        return `Unexpected "${physicalProperty}" property. Use "${logicalProperty}".`;
+    },
+    unexpectedValue(property, physicalValue, logicalValue) {
+        return `Unexpected "${physicalValue}" value in "${property}" property. Use "${logicalValue}".`;
+    },
+    unsupportedProp(physicalProperty, logicalProperty) {
+        return `"${physicalProperty}" is not part of CSS specs. Use "${logicalProperty[0]}" and "${logicalProperty[1]}".`;
+    },
+});

package/dist/lib/rule-name.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "liberty/use-logical-spec";
+export default _default;

package/dist/lib/rule-name.js

@@ -0,0 +1 @@
+export default 'liberty/use-logical-spec';

package/dist/lib/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ChildNode, Container, Declaration } from 'postcss';
+type ValidationCallback = (...args: (Declaration | number)[]) => void;
+export declare const validateRuleWithProps: (root: Container | ChildNode, props: string[], fn: ValidationCallback) => void;
+export {};

package/dist/lib/validate.js

@@ -0,0 +1,19 @@
+export const validateRuleWithProps = (root, props, fn) => {
+    // For supporting css-in-js
+    const { nodes = [root] } = root;
+    // conditionally walk nodes with children
+    if (nodes && nodes.length) {
+        const args = [];
+        const hasProps = props.every(prop => {
+            const declIndex = nodes.findIndex(child => child.type === 'decl' && child.prop === prop);
+            const decl = nodes[declIndex];
+            if (decl) {
+                args.push(decl, declIndex);
+            }
+            return decl;
+        });
+        if (hasProps) {
+            fn(...args);
+        }
+    }
+};

package/dist/lib/value-split.d.ts

@@ -0,0 +1 @@
+export declare const cssValueSplit: (value: string) => string[];

package/dist/lib/value-split.js

@@ -0,0 +1,48 @@
+export const cssValueSplit = (value) => {
+    const ret = [];
+    const stack = [];
+    let part = '';
+    let esc = false;
+    let q = '';
+    for (let i = 0; i < value.length; i++) {
+        const c = value[i];
+        if (esc) {
+            esc = false;
+        }
+        else if (c === '\\') {
+            esc = true;
+        }
+        else if (q) {
+            if (c === q) {
+                q = '';
+            }
+        }
+        else if (c === "'" || c === '"') {
+            q = c;
+        }
+        else if (c === ' ' && stack.length === 0) {
+            if (part) {
+                ret.push(part);
+            }
+            part = '';
+            continue;
+        }
+        else if (c === '(') {
+            stack.push(')');
+        }
+        else if (c === '{') {
+            stack.push('}');
+        }
+        else if (c === '[') {
+            stack.push(']');
+        }
+        else if (stack.length && c === stack[stack.length - 1]) {
+            stack.length--;
+        }
+        part += c;
+    }
+    if (part) {
+        ret.push(part);
+    }
+    return ret;
+};

package/dist/lib/walk.d.ts

@@ -0,0 +1,2 @@
+import type { ChildNode, Container } from 'postcss';
+export default function walk(node: Container | ChildNode, fn: (child: ChildNode) => void): void;

package/dist/lib/walk.js

@@ -0,0 +1,18 @@
+// walk all container nodes
+export default function walk(node, fn) {
+    const container = node;
+    if (container.nodes && container.nodes.length) {
+        const nodes = container.nodes.slice();
+        const length = nodes.length;
+        let index = -1;
+        while (++index < length) {
+            const child = nodes[index];
+            if (!isDirRule(child)) {
+                fn(child);
+                walk(child, fn);
+            }
+        }
+    }
+}
+const dirSelectorRegExp = /:dir\(ltr|rtl\)/i;
+const isDirRule = (node) => node.type === 'rule' && dirSelectorRegExp.test(node.selector);

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "stylelint-logical-spec",
+  "version": "6.0.0",
+  "description": "Enforce usage of logical properties and values in CSS",
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepack": "npm run build",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bleeding-gums/stylelint-logical-spec.git"
+  },
+  "homepage": "https://github.com/bleeding-gums/stylelint-logical-spec#readme",
+  "bugs": "https://github.com/bleeding-gums/stylelint-logical-spec/issues",
+  "keywords": [
+    "stylelint-plugin",
+    "css",
+    "logical",
+    "properties"
+  ],
+  "license": "CC0-1.0",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "@types/stylelint": "^14.0.0",
+    "jest": "^29.7.0",
+    "jest-preset-stylelint": "^9.1.0",
+    "stylelint": "^17.1.1",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "stylelint": "^16.0.0 || ^17.0.0"
+  }
+}