@spiracss/stylelint-plugin 0.2.2 → 0.3.1

package/dist/cjs/rules/spiracss-property-placement.js

@@ -0,0 +1,646 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleName = void 0;
+const stylelint_1 = __importDefault(require("stylelint"));
+const constants_1 = require("../utils/constants");
+const naming_1 = require("../utils/naming");
+const messages_1 = require("../utils/messages");
+const selector_policy_1 = require("../utils/selector-policy");
+const option_schema_1 = require("../utils/option-schema");
+const postcss_helpers_1 = require("../utils/postcss-helpers");
+const section_1 = require("../utils/section");
+const selector_1 = require("../utils/selector");
+const stylelint_2 = require("../utils/stylelint");
+const rule_docs_1 = require("../utils/rule-docs");
+const validate_1 = require("../utils/validate");
+const spiracss_class_structure_patterns_1 = require("./spiracss-class-structure.patterns");
+const spiracss_class_structure_selectors_1 = require("./spiracss-class-structure.selectors");
+const spiracss_class_structure_sections_1 = require("./spiracss-class-structure.sections");
+const spiracss_property_placement_constants_1 = require("./spiracss-property-placement.constants");
+Object.defineProperty(exports, "ruleName", { enumerable: true, get: function () { return spiracss_property_placement_constants_1.ruleName; } });
+const spiracss_property_placement_messages_1 = require("./spiracss-property-placement.messages");
+const spiracss_property_placement_options_1 = require("./spiracss-property-placement.options");
+const spiracss_property_placement_selectors_1 = require("./spiracss-property-placement.selectors");
+const spiracss_property_placement_values_1 = require("./spiracss-property-placement.values");
+const meta = {
+    url: (0, rule_docs_1.getRuleDocsUrl)(spiracss_property_placement_constants_1.ruleName),
+    fixable: false,
+    description: 'Enforce SpiraCSS property placement rules (container/item/internal).',
+    category: 'stylistic'
+};
+const optionSchema = {
+    elementDepth: [validate_1.isNumber],
+    marginSide: [validate_1.isString],
+    position: [validate_1.isBoolean],
+    sizeInternal: [validate_1.isBoolean],
+    responsiveMixins: [validate_1.isString],
+    ...option_schema_1.NAMING_SCHEMA,
+    ...option_schema_1.COMMENTS_SCHEMA,
+    ...option_schema_1.POLICY_SCHEMA,
+    ...option_schema_1.EXTERNAL_SCHEMA,
+    ...option_schema_1.CACHE_SCHEMA
+};
+const CONTAINER_PROP_NAMES = new Set([
+    'flex-direction',
+    'flex-wrap',
+    'gap',
+    'row-gap',
+    'column-gap',
+    'justify-content',
+    'justify-items',
+    'align-content',
+    'align-items'
+]);
+const ITEM_PROP_NAMES = new Set([
+    'margin',
+    'margin-top',
+    'margin-bottom',
+    'margin-left',
+    'margin-right',
+    'margin-inline',
+    'margin-inline-start',
+    'margin-inline-end',
+    'margin-block',
+    'margin-block-start',
+    'margin-block-end',
+    'flex',
+    'flex-grow',
+    'flex-shrink',
+    'flex-basis',
+    'order',
+    'align-self',
+    'justify-self',
+    'grid-column',
+    'grid-row',
+    'grid-area'
+]);
+const MARGIN_SIDE_PROP_NAMES = new Set([
+    'margin',
+    'margin-top',
+    'margin-bottom',
+    'margin-block',
+    'margin-block-start',
+    'margin-block-end'
+]);
+const DISPLAY_ALLOWED = new Set(['flex', 'inline-flex', 'grid', 'inline-grid']);
+const OVERFLOW_PROP_NAMES = new Set(['overflow', 'overflow-x', 'overflow-y']);
+const OFFSET_PROP_NAMES = new Set([
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'inset',
+    'inset-block',
+    'inset-inline',
+    'inset-block-start',
+    'inset-block-end',
+    'inset-inline-start',
+    'inset-inline-end'
+]);
+const isPaddingProp = (prop) => prop === 'padding' || prop.startsWith('padding-');
+const isContainerProp = (decl) => {
+    const prop = decl.prop.toLowerCase();
+    if (prop === 'display') {
+        const tokens = decl.value
+            .trim()
+            .toLowerCase()
+            .split(/\s+|!/)
+            .filter((token) => token.length > 0 && token !== 'important');
+        return tokens.some((token) => DISPLAY_ALLOWED.has(token));
+    }
+    if (prop === 'grid')
+        return true;
+    if (prop === 'grid-template' || prop.startsWith('grid-template-'))
+        return true;
+    if (prop.startsWith('grid-auto-'))
+        return true;
+    return CONTAINER_PROP_NAMES.has(prop);
+};
+const isItemProp = (prop) => ITEM_PROP_NAMES.has(prop);
+const isMarginSideProp = (prop) => MARGIN_SIDE_PROP_NAMES.has(prop);
+const isOverflowProp = (prop) => OVERFLOW_PROP_NAMES.has(prop);
+const isSizeInternalProp = (prop) => prop === 'width' ||
+    prop === 'height' ||
+    prop === 'inline-size' ||
+    prop === 'block-size' ||
+    prop.startsWith('min-') ||
+    prop.startsWith('max-');
+const isInternalProp = (prop, enableSizeInternal) => isPaddingProp(prop) ||
+    isOverflowProp(prop) ||
+    (enableSizeInternal && isSizeInternalProp(prop));
+const isInsideAtRoot = (node) => {
+    let current = node.parent ?? undefined;
+    while (current) {
+        if ((0, postcss_helpers_1.isAtRule)(current) && current.name === 'at-root')
+            return true;
+        current = current.parent ?? undefined;
+    }
+    return false;
+};
+const rule = (0, stylelint_2.createRule)(spiracss_property_placement_constants_1.ruleName, spiracss_property_placement_messages_1.messages, (primaryOption, secondaryOption, _context) => {
+    if (primaryOption === false) {
+        return () => {
+            /* rule disabled */
+        };
+    }
+    const rawOptions = typeof primaryOption === 'object' && primaryOption !== null
+        ? primaryOption
+        : secondaryOption;
+    let cache = null;
+    const getCache = (reportInvalid) => {
+        if (cache)
+            return cache;
+        let hasInvalidOptions = false;
+        const handleInvalid = reportInvalid
+            ? (optionName, value, detail) => {
+                hasInvalidOptions = true;
+                reportInvalid(optionName, value, detail);
+            }
+            : undefined;
+        const options = (0, spiracss_property_placement_options_1.normalizeOptions)(rawOptions, handleInvalid);
+        const classifyOptions = {
+            external: options.external,
+            naming: options.naming
+        };
+        const customModifierPattern = (0, naming_1.normalizeCustomPattern)(options.naming?.customPatterns?.modifier, 'naming.customPatterns.modifier');
+        cache = {
+            options,
+            patterns: (0, spiracss_class_structure_patterns_1.buildPatterns)(classifyOptions, options.cache, handleInvalid),
+            policySets: (0, spiracss_property_placement_selectors_1.buildPolicySets)(options.selectorPolicy),
+            classifyOptions,
+            customModifierPattern,
+            hasInvalidOptions
+        };
+        return cache;
+    };
+    return (root, result) => {
+        const shouldValidate = result.stylelint?.config?.validate !== false;
+        if (shouldValidate) {
+            const validOptions = stylelint_1.default.utils.validateOptions(result, spiracss_property_placement_constants_1.ruleName, {
+                actual: primaryOption,
+                possible: [true, validate_1.isPlainObject]
+            }, {
+                actual: secondaryOption,
+                possible: validate_1.isPlainObject,
+                optional: true
+            }, {
+                actual: rawOptions,
+                possible: optionSchema,
+                optional: true
+            });
+            if (!validOptions)
+                return;
+        }
+        const reportInvalid = shouldValidate
+            ? (optionName, value, detail) => {
+                (0, stylelint_2.reportInvalidOption)(result, spiracss_property_placement_constants_1.ruleName, optionName, value, detail);
+            }
+            : undefined;
+        const hasInvalid = (0, stylelint_2.validateOptionsArrayFields)(rawOptions, ['external.classes', 'external.prefixes', 'responsiveMixins'], validate_1.isStringArray, reportInvalid, (optionName) => `[spiracss] ${optionName} must be an array of non-empty strings.`);
+        if (shouldValidate && hasInvalid)
+            return;
+        const { options, patterns, policySets, classifyOptions, customModifierPattern, hasInvalidOptions } = getCache(reportInvalid);
+        if (shouldValidate && hasInvalidOptions)
+            return;
+        const cacheSizes = options.cache;
+        const selectorState = (0, selector_1.createSelectorCacheWithErrorFlag)(cacheSizes.selector);
+        const selectorCache = selectorState.cache;
+        const resolvedSelectorsCache = new WeakMap();
+        const ruleAnalysisCache = new WeakMap();
+        const globalOnlyRuleCache = new WeakMap();
+        const ruleFamilyKeysCache = new WeakMap();
+        const wrapperKeyCache = new WeakMap();
+        const atRuleIds = new WeakMap();
+        let atRuleIdSeed = 0;
+        let firstRule = null;
+        const responsiveMixins = new Set(options.responsive.mixins.map((name) => name.toLowerCase()));
+        const { checkMarginSide, parsePositionValue, isZeroMinSize } = (0, spiracss_property_placement_values_1.createValueTokenHelpers)();
+        const selectorPolicy = options.selectorPolicy;
+        const variantMode = selectorPolicy.variant.mode;
+        const stateMode = selectorPolicy.state.mode;
+        // Display lowercase keys in messages to match actual selector matching behavior.
+        const { variantKeys, stateKeys } = (0, selector_policy_1.getLowercasePolicyKeys)(selectorPolicy);
+        const naming = options.naming ?? {};
+        const modifierPrefix = naming.modifierPrefix ?? '-';
+        const modifierCase = naming.modifierCase ?? 'kebab';
+        const modifierPattern = customModifierPattern ?? '';
+        const getAtRuleId = (atRule) => {
+            const cached = atRuleIds.get(atRule);
+            if (cached)
+                return cached;
+            atRuleIdSeed += 1;
+            atRuleIds.set(atRule, atRuleIdSeed);
+            return atRuleIdSeed;
+        };
+        const rootBlockRules = new WeakSet();
+        const declsByRule = new Map();
+        root.walk((node) => {
+            if (node.type === 'rule') {
+                const rule = node;
+                if (!firstRule)
+                    firstRule = rule;
+                if ((0, section_1.isRuleInsideAtRule)(rule, constants_1.NON_SELECTOR_AT_RULE_NAMES))
+                    return;
+                if ((0, postcss_helpers_1.findParentRule)(rule))
+                    return;
+                if (!(0, spiracss_class_structure_sections_1.isRootBlockRule)(rule))
+                    return;
+                if (typeof rule.selector !== 'string')
+                    return;
+                const selectorTexts = (0, spiracss_property_placement_selectors_1.splitSelectors)(rule.selector, selectorCache);
+                // Root block detection strips :global parts while preserving leading combinators.
+                const localSelectors = selectorTexts
+                    .map((selector) => (0, spiracss_property_placement_selectors_1.stripGlobalSelectorForRoot)(selector, selectorCache, options.cache.selector, {
+                    preserveCombinator: true
+                }))
+                    .filter((selector) => Boolean(selector));
+                if (localSelectors.length === 0)
+                    return;
+                const selectors = localSelectors.flatMap((selector) => selectorCache.parse(selector));
+                const rootBlocks = (0, spiracss_class_structure_selectors_1.collectRootBlockNames)(selectors, classifyOptions, patterns);
+                if (rootBlocks.length === 0)
+                    return;
+                rootBlockRules.add(rule);
+                return;
+            }
+            if (node.type === 'decl') {
+                const decl = node;
+                const parentRule = (0, postcss_helpers_1.findParentRule)(decl);
+                if (!parentRule)
+                    return;
+                const bucket = declsByRule.get(parentRule);
+                if (bucket) {
+                    bucket.push(decl);
+                }
+                else {
+                    declsByRule.set(parentRule, [decl]);
+                }
+                return;
+            }
+        });
+        const commentPatterns = {
+            sharedCommentPattern: options.comments.shared,
+            interactionCommentPattern: options.comments.interaction
+        };
+        const interactionContainers = (0, section_1.markInteractionContainers)(root, commentPatterns, (_comment, parent) => (0, postcss_helpers_1.isRule)(parent) && rootBlockRules.has(parent));
+        const selectorExplosion = { example: null, limit: 0 };
+        const reportSelectorExplosion = (selector, limit) => {
+            if (!selectorExplosion.example)
+                selectorExplosion.example = selector;
+            selectorExplosion.limit = limit;
+        };
+        const getResolvedSelectors = (rule) => (0, spiracss_property_placement_selectors_1.resolveSelectors)(rule, selectorCache, resolvedSelectorsCache, reportSelectorExplosion);
+        const resolveContextSelector = (rule) => {
+            if (!rule || typeof rule.selector !== 'string')
+                return '(unknown)';
+            const resolved = getResolvedSelectors(rule);
+            if (resolved.length > 0)
+                return resolved.join(', ');
+            return rule.selector;
+        };
+        const isGlobalOnlyRule = (rule) => {
+            const cached = globalOnlyRuleCache.get(rule);
+            if (cached !== undefined)
+                return cached;
+            // If a rule has no non-:global selectors, treat it as out-of-scope for enforcement.
+            const resolved = getResolvedSelectors(rule);
+            const value = resolved.length > 0 &&
+                resolved.every((selector) => (0, spiracss_property_placement_selectors_1.isGlobalOnlySelector)(selector, selectorCache, options.cache.selector));
+            globalOnlyRuleCache.set(rule, value);
+            return value;
+        };
+        const getRuleAnalysis = (rule) => {
+            const cached = ruleAnalysisCache.get(rule);
+            if (cached)
+                return cached;
+            const resolvedSelectors = getResolvedSelectors(rule);
+            const analysis = resolvedSelectors.length === 0
+                ? { status: 'skip' }
+                : (0, spiracss_property_placement_selectors_1.analyzeSelectorList)(resolvedSelectors, selectorCache, options, policySets, patterns, classifyOptions);
+            const entry = {
+                resolvedSelectors,
+                analysis,
+                resolvedSelectorText: resolvedSelectors.join(', ')
+            };
+            ruleAnalysisCache.set(rule, entry);
+            return entry;
+        };
+        const getRuleFamilyKeys = (rule) => {
+            if (ruleFamilyKeysCache.has(rule)) {
+                return ruleFamilyKeysCache.get(rule) ?? null;
+            }
+            const { analysis } = getRuleAnalysis(rule);
+            if (analysis.status !== 'ok') {
+                ruleFamilyKeysCache.set(rule, null);
+                return null;
+            }
+            const keys = analysis.familyKeys;
+            if (keys.length === 0) {
+                ruleFamilyKeysCache.set(rule, null);
+                return null;
+            }
+            ruleFamilyKeysCache.set(rule, keys);
+            return keys;
+        };
+        const getWrapperContextKey = (node) => {
+            const cached = wrapperKeyCache.get(node);
+            if (cached)
+                return cached;
+            const parts = [];
+            let current = node.parent ?? undefined;
+            while (current) {
+                if ((0, postcss_helpers_1.isAtRule)(current)) {
+                    const name = current.name ? current.name.toLowerCase() : '';
+                    if (name === 'scope') {
+                        const params = typeof current.params === 'string' ? current.params : '';
+                        const normalized = (0, spiracss_property_placement_selectors_1.normalizeScopePrelude)(params);
+                        if (normalized) {
+                            parts.push(`scope:${normalized}`);
+                        }
+                        else {
+                            const fallback = (0, spiracss_property_placement_selectors_1.normalizeUnverifiedScopePrelude)(params);
+                            parts.push(`scope:unverified:${fallback ?? getAtRuleId(current)}`);
+                        }
+                    }
+                    else if (constants_1.ROOT_WRAPPER_NAMES.has(name)) {
+                        // allowed wrapper
+                    }
+                    else if (name === 'include') {
+                        const params = typeof current.params === 'string' ? current.params : '';
+                        const mixinName = (0, spiracss_property_placement_selectors_1.parseMixinName)(params);
+                        const allowlisted = mixinName
+                            ? responsiveMixins.has(mixinName.toLowerCase())
+                            : false;
+                        if (!allowlisted) {
+                            parts.push(`include:${getAtRuleId(current)}`);
+                        }
+                    }
+                    else {
+                        const keyName = name || 'unknown';
+                        parts.push(`atrule:${keyName}:${getAtRuleId(current)}`);
+                    }
+                }
+                current = current.parent ?? undefined;
+            }
+            let key = 'ctx:root';
+            if (parts.length > 0) {
+                let context = '';
+                for (let i = parts.length - 1; i >= 0; i -= 1) {
+                    context += `${context ? '|' : ''}${parts[i]}`;
+                }
+                key = `ctx:${context}`;
+            }
+            wrapperKeyCache.set(node, key);
+            return key;
+        };
+        const familyOffsetMap = new Map();
+        if (options.position) {
+            for (const [rule, decls] of declsByRule) {
+                if (interactionContainers.has(rule))
+                    continue;
+                if ((0, section_1.isRuleInsideAtRule)(rule, constants_1.NON_SELECTOR_AT_RULE_NAMES))
+                    continue;
+                const familyKeys = getRuleFamilyKeys(rule);
+                if (!familyKeys)
+                    continue;
+                const ruleWrapperKey = getWrapperContextKey(rule);
+                for (const decl of decls) {
+                    if (isInsideAtRoot(decl))
+                        continue;
+                    const prop = decl.prop.toLowerCase();
+                    if (!OFFSET_PROP_NAMES.has(prop))
+                        continue;
+                    const wrapperKey = decl.parent === rule ? ruleWrapperKey : getWrapperContextKey(decl);
+                    familyKeys.forEach((key) => {
+                        familyOffsetMap.set(`${wrapperKey}::${key}`, true);
+                    });
+                }
+            }
+        }
+        root.walkAtRules((atRule) => {
+            const name = atRule.name ? atRule.name.toLowerCase() : '';
+            const parentRule = (0, postcss_helpers_1.findParentRule)(atRule);
+            if (parentRule && isGlobalOnlyRule(parentRule))
+                return;
+            if (name === 'extend') {
+                const placeholder = atRule.params?.trim() || '%unknown';
+                const parentSelector = resolveContextSelector(parentRule);
+                stylelint_1.default.utils.report({
+                    ruleName: spiracss_property_placement_constants_1.ruleName,
+                    result,
+                    node: atRule,
+                    message: spiracss_property_placement_messages_1.messages.forbiddenExtend(parentSelector, placeholder)
+                });
+                return;
+            }
+            if (name === 'at-root') {
+                if (interactionContainers.has(atRule))
+                    return;
+                const parentSelector = resolveContextSelector(parentRule);
+                stylelint_1.default.utils.report({
+                    ruleName: spiracss_property_placement_constants_1.ruleName,
+                    result,
+                    node: atRule,
+                    message: spiracss_property_placement_messages_1.messages.forbiddenAtRoot(parentSelector, options.comments.interaction)
+                });
+            }
+        });
+        for (const [rule, decls] of declsByRule) {
+            if ((0, section_1.isRuleInsideAtRule)(rule, constants_1.NON_SELECTOR_AT_RULE_NAMES))
+                continue;
+            if (interactionContainers.has(rule))
+                continue;
+            if (isInsideAtRoot(rule))
+                continue;
+            if (typeof rule.selector !== 'string')
+                continue;
+            const { analysis, resolvedSelectorText } = getRuleAnalysis(rule);
+            if (analysis.status === 'skip')
+                continue;
+            if (analysis.status === 'error') {
+                stylelint_1.default.utils.report({
+                    ruleName: spiracss_property_placement_constants_1.ruleName,
+                    result,
+                    node: rule,
+                    message: analysis.message
+                });
+                continue;
+            }
+            const selectorInfos = analysis.selectors;
+            const resolvedSelector = resolvedSelectorText;
+            const ruleWrapperKey = getWrapperContextKey(rule);
+            decls.forEach((decl) => {
+                if (isInsideAtRoot(decl))
+                    return;
+                const prop = decl.prop.toLowerCase();
+                if (!prop || prop.startsWith('--'))
+                    return;
+                if (isContainerProp(decl)) {
+                    const hasPageRoot = selectorInfos.some((info) => info.kind === 'page-root');
+                    if (hasPageRoot) {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.pageRootContainer(prop, resolvedSelector)
+                        });
+                        return;
+                    }
+                    const hasChildBlock = selectorInfos.some((info) => info.kind === 'child-block');
+                    if (!hasChildBlock)
+                        return;
+                    stylelint_1.default.utils.report({
+                        ruleName: spiracss_property_placement_constants_1.ruleName,
+                        result,
+                        node: decl,
+                        message: spiracss_property_placement_messages_1.messages.containerInChildBlock(prop, resolvedSelector)
+                    });
+                    return;
+                }
+                if (isItemProp(prop)) {
+                    const hasPageRoot = selectorInfos.some((info) => info.kind === 'page-root');
+                    if (hasPageRoot) {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.pageRootItem(prop, resolvedSelector)
+                        });
+                        return;
+                    }
+                    const hasInvalidPlacement = selectorInfos.some((info) => {
+                        if (info.kind === 'root')
+                            return true;
+                        return info.tailCombinator === null;
+                    });
+                    if (hasInvalidPlacement) {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.itemInRoot(prop, resolvedSelector)
+                        });
+                        return;
+                    }
+                    if (isMarginSideProp(prop)) {
+                        const marginSideResult = checkMarginSide(prop, decl.value, options.margin.side);
+                        if (marginSideResult === 'error') {
+                            const disallowedSide = options.margin.side === 'top' ? 'bottom' : 'top';
+                            stylelint_1.default.utils.report({
+                                ruleName: spiracss_property_placement_constants_1.ruleName,
+                                result,
+                                node: decl,
+                                message: spiracss_property_placement_messages_1.messages.marginSideViolation(prop, resolvedSelector, disallowedSide)
+                            });
+                        }
+                    }
+                    return;
+                }
+                if (isInternalProp(prop, options.size.internal)) {
+                    // Allow min-* = 0 everywhere (self/item-side exception) before internal checks.
+                    if (options.size.internal && isZeroMinSize(prop, decl.value))
+                        return;
+                    const hasPageRoot = selectorInfos.some((info) => info.kind === 'page-root');
+                    if (hasPageRoot) {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.pageRootInternal(prop, resolvedSelector)
+                        });
+                        return;
+                    }
+                    const hasChildBlock = selectorInfos.some((info) => info.kind === 'child-block');
+                    if (!hasChildBlock)
+                        return;
+                    stylelint_1.default.utils.report({
+                        ruleName: spiracss_property_placement_constants_1.ruleName,
+                        result,
+                        node: decl,
+                        message: spiracss_property_placement_messages_1.messages.internalInChildBlock(prop, resolvedSelector, variantMode, variantKeys, stateMode, stateKeys, modifierPrefix, modifierCase, modifierPattern)
+                    });
+                    return;
+                }
+                if (options.position && prop === 'position') {
+                    const hasChildBlock = selectorInfos.some((info) => info.kind === 'child-block');
+                    if (!hasChildBlock)
+                        return;
+                    const parsedPosition = parsePositionValue(decl.value);
+                    if (parsedPosition.status === 'skip')
+                        return;
+                    if (parsedPosition.status === 'unknown') {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.positionInChildBlock(parsedPosition.value, resolvedSelector, options.responsive.mixins, parsedPosition.reason)
+                        });
+                        return;
+                    }
+                    if (parsedPosition.value === 'static')
+                        return;
+                    if (parsedPosition.value === 'fixed' || parsedPosition.value === 'sticky') {
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.positionInChildBlock(parsedPosition.value, resolvedSelector, options.responsive.mixins)
+                        });
+                        return;
+                    }
+                    if (parsedPosition.value === 'relative' || parsedPosition.value === 'absolute') {
+                        if (analysis.hasUnverifiedFamilyKeys) {
+                            stylelint_1.default.utils.report({
+                                ruleName: spiracss_property_placement_constants_1.ruleName,
+                                result,
+                                node: decl,
+                                message: spiracss_property_placement_messages_1.messages.positionInChildBlock(parsedPosition.value, resolvedSelector, options.responsive.mixins)
+                            });
+                            return;
+                        }
+                        const familyKeys = getRuleFamilyKeys(rule);
+                        if (!familyKeys)
+                            return;
+                        const wrapperKey = decl.parent === rule ? ruleWrapperKey : getWrapperContextKey(decl);
+                        // Require offsets for every selector in a list to avoid partial matches.
+                        const hasOffsets = familyKeys.every((key) => familyOffsetMap.has(`${wrapperKey}::${key}`));
+                        if (hasOffsets)
+                            return;
+                        stylelint_1.default.utils.report({
+                            ruleName: spiracss_property_placement_constants_1.ruleName,
+                            result,
+                            node: decl,
+                            message: spiracss_property_placement_messages_1.messages.positionInChildBlock(parsedPosition.value, resolvedSelector, options.responsive.mixins)
+                        });
+                    }
+                }
+            });
+        }
+        if (selectorState.hasError()) {
+            const targetNode = firstRule || root;
+            stylelint_1.default.utils.report({
+                ruleName: spiracss_property_placement_constants_1.ruleName,
+                result,
+                node: targetNode,
+                message: spiracss_property_placement_messages_1.messages.selectorParseFailed(...(0, messages_1.selectorParseFailedArgs)(selectorState.getErrorSelector())),
+                severity: 'warning'
+            });
+        }
+        if (selectorExplosion.example) {
+            const targetNode = firstRule || root;
+            stylelint_1.default.utils.report({
+                ruleName: spiracss_property_placement_constants_1.ruleName,
+                result,
+                node: targetNode,
+                message: spiracss_property_placement_messages_1.messages.selectorResolutionSkipped(selectorExplosion.limit, selectorExplosion.example),
+                severity: 'warning'
+            });
+        }
+    };
+}, meta);
+const spiracssPropertyPlacement = (0, stylelint_2.createPlugin)(spiracss_property_placement_constants_1.ruleName, rule);
+exports.default = spiracssPropertyPlacement;
+//# sourceMappingURL=spiracss-property-placement.js.map