@savvy-web/changesets 0.1.0 → 0.1.1

package/cjs/markdownlint.cjs

@@ -0,0 +1,312 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ContentStructureRule: ()=>ContentStructureRule,
+    HeadingHierarchyRule: ()=>HeadingHierarchyRule,
+    default: ()=>markdownlint,
+    RequiredSectionsRule: ()=>RequiredSectionsRule
+});
+function getHeadingLevel(heading) {
+    const sequence = heading.children.find((c)=>"atxHeadingSequence" === c.type);
+    return sequence ? sequence.text.length : 0;
+}
+function getHeadingText(heading) {
+    const textToken = heading.children.find((c)=>"atxHeadingText" === c.type);
+    return textToken ? textToken.text : "";
+}
+function hasContentBetween(tokens, currentIdx, nextIdx) {
+    for(let i = currentIdx + 1; i < nextIdx; i++){
+        const token = tokens[i];
+        if ("lineEnding" !== token.type && "lineEndingBlank" !== token.type) return true;
+    }
+    return false;
+}
+const ContentStructureRule = {
+    names: [
+        "changeset-content-structure",
+        "CSH003"
+    ],
+    description: "Sections must have content, code blocks need languages, list items need text",
+    tags: [
+        "changeset"
+    ],
+    parser: "micromark",
+    function: function(params, onError) {
+        const tokens = params.parsers.micromark.tokens;
+        const h2Indices = [];
+        for(let i = 0; i < tokens.length; i++)if ("atxHeading" === tokens[i].type && 2 === getHeadingLevel(tokens[i])) h2Indices.push(i);
+        for(let i = 0; i < h2Indices.length; i++){
+            const currentIdx = h2Indices[i];
+            const nextIdx = i + 1 < h2Indices.length ? h2Indices[i + 1] : tokens.length;
+            if (!hasContentBetween(tokens, currentIdx, nextIdx)) onError({
+                lineNumber: tokens[currentIdx].startLine,
+                detail: "Empty section: heading has no content before the next section or end of file"
+            });
+        }
+        for (const token of tokens){
+            if ("codeFenced" !== token.type) continue;
+            const openingFence = token.children.find((c)=>"codeFencedFence" === c.type);
+            const hasInfo = openingFence?.children.some((c)=>"codeFencedFenceInfo" === c.type) ?? false;
+            if (!hasInfo) onError({
+                lineNumber: token.startLine,
+                detail: "Code block is missing a language identifier"
+            });
+        }
+        for (const token of tokens){
+            if ("listOrdered" !== token.type && "listUnordered" !== token.type) continue;
+            const children = token.children;
+            for(let i = 0; i < children.length; i++){
+                if ("listItemPrefix" !== children[i].type) continue;
+                let hasContent = false;
+                for(let j = i + 1; j < children.length; j++){
+                    if ("listItemPrefix" === children[j].type) break;
+                    if ("content" === children[j].type) {
+                        hasContent = true;
+                        break;
+                    }
+                }
+                if (!hasContent) onError({
+                    lineNumber: children[i].startLine,
+                    detail: "Empty list item"
+                });
+            }
+        }
+    }
+};
+const HeadingHierarchyRule = {
+    names: [
+        "changeset-heading-hierarchy",
+        "CSH001"
+    ],
+    description: "Heading hierarchy must start at h2 with no h1 or depth skips",
+    tags: [
+        "changeset"
+    ],
+    parser: "micromark",
+    function: function(params, onError) {
+        let prevDepth = 0;
+        for (const token of params.parsers.micromark.tokens){
+            if ("atxHeading" !== token.type) continue;
+            const depth = getHeadingLevel(token);
+            if (1 === depth) {
+                onError({
+                    lineNumber: token.startLine,
+                    detail: "h1 headings are not allowed in changeset files"
+                });
+                continue;
+            }
+            if (prevDepth > 0 && depth > prevDepth + 1) onError({
+                lineNumber: token.startLine,
+                detail: `Heading level skipped: expected h${prevDepth + 1} or lower, found h${depth}`
+            });
+            prevDepth = depth;
+        }
+    }
+};
+const BREAKING_CHANGES = {
+    heading: "Breaking Changes",
+    priority: 1,
+    commitTypes: [],
+    description: "Backward-incompatible changes"
+};
+const FEATURES = {
+    heading: "Features",
+    priority: 2,
+    commitTypes: [
+        "feat"
+    ],
+    description: "New functionality"
+};
+const BUG_FIXES = {
+    heading: "Bug Fixes",
+    priority: 3,
+    commitTypes: [
+        "fix"
+    ],
+    description: "Bug corrections"
+};
+const PERFORMANCE = {
+    heading: "Performance",
+    priority: 4,
+    commitTypes: [
+        "perf"
+    ],
+    description: "Performance improvements"
+};
+const DOCUMENTATION = {
+    heading: "Documentation",
+    priority: 5,
+    commitTypes: [
+        "docs"
+    ],
+    description: "Documentation changes"
+};
+const REFACTORING = {
+    heading: "Refactoring",
+    priority: 6,
+    commitTypes: [
+        "refactor"
+    ],
+    description: "Code restructuring"
+};
+const TESTS = {
+    heading: "Tests",
+    priority: 7,
+    commitTypes: [
+        "test"
+    ],
+    description: "Test additions or modifications"
+};
+const BUILD_SYSTEM = {
+    heading: "Build System",
+    priority: 8,
+    commitTypes: [
+        "build"
+    ],
+    description: "Build configuration changes"
+};
+const CI = {
+    heading: "CI",
+    priority: 9,
+    commitTypes: [
+        "ci"
+    ],
+    description: "Continuous integration changes"
+};
+const DEPENDENCIES = {
+    heading: "Dependencies",
+    priority: 10,
+    commitTypes: [
+        "deps"
+    ],
+    description: "Dependency updates"
+};
+const MAINTENANCE = {
+    heading: "Maintenance",
+    priority: 11,
+    commitTypes: [
+        "chore",
+        "style"
+    ],
+    description: "General maintenance"
+};
+const REVERTS = {
+    heading: "Reverts",
+    priority: 12,
+    commitTypes: [
+        "revert"
+    ],
+    description: "Reverted changes"
+};
+const OTHER = {
+    heading: "Other",
+    priority: 13,
+    commitTypes: [],
+    description: "Uncategorized changes"
+};
+const CATEGORIES = [
+    BREAKING_CHANGES,
+    FEATURES,
+    BUG_FIXES,
+    PERFORMANCE,
+    DOCUMENTATION,
+    REFACTORING,
+    TESTS,
+    BUILD_SYSTEM,
+    CI,
+    DEPENDENCIES,
+    MAINTENANCE,
+    REVERTS,
+    OTHER
+];
+const headingToCategory = new Map(CATEGORIES.map((cat)=>[
+        cat.heading.toLowerCase(),
+        cat
+    ]));
+const commitTypeToCategory = new Map();
+for (const cat of CATEGORIES)for (const commitType of cat.commitTypes)commitTypeToCategory.set(commitType, cat);
+function isValidHeading(heading) {
+    return headingToCategory.has(heading.toLowerCase());
+}
+function allHeadings() {
+    return CATEGORIES.map((cat)=>cat.heading);
+}
+const RequiredSectionsRule = {
+    names: [
+        "changeset-required-sections",
+        "CSH002"
+    ],
+    description: "Section headings must match known changeset categories",
+    tags: [
+        "changeset"
+    ],
+    parser: "micromark",
+    function: function(params, onError) {
+        for (const token of params.parsers.micromark.tokens){
+            if ("atxHeading" !== token.type) continue;
+            if (2 !== getHeadingLevel(token)) continue;
+            const text = getHeadingText(token);
+            if (!isValidHeading(text)) onError({
+                lineNumber: token.startLine,
+                detail: `Unknown section "${text}". Valid sections: ${allHeadings().join(", ")}`
+            });
+        }
+    }
+};
+const SilkChangesetsRules = [
+    HeadingHierarchyRule,
+    RequiredSectionsRule,
+    ContentStructureRule
+];
+const markdownlint = SilkChangesetsRules;
+exports.ContentStructureRule = __webpack_exports__.ContentStructureRule;
+exports.HeadingHierarchyRule = __webpack_exports__.HeadingHierarchyRule;
+exports.RequiredSectionsRule = __webpack_exports__.RequiredSectionsRule;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ContentStructureRule",
+    "HeadingHierarchyRule",
+    "RequiredSectionsRule",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+
+if (module.exports && module.exports.__esModule && 'default' in module.exports) {
+  var _def = module.exports.default;
+  if (_def !== null && _def !== undefined && (typeof _def === 'object' || typeof _def === 'function')) {
+    var _keys = Object.keys(module.exports);
+    for (var _i = 0; _i < _keys.length; _i++) {
+      var _key = _keys[_i];
+      if (_key !== 'default' && _key !== '__esModule' && !(_key in _def)) {
+        _def[_key] = module.exports[_key];
+      }
+    }
+  }
+  module.exports = _def;
+}