@savvy-web/changesets 0.1.0 → 0.1.1

package/cjs/remark.cjs

@@ -0,0 +1,559 @@
+"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__, {
+    SilkChangesetTransformPreset: ()=>SilkChangesetTransformPreset,
+    NormalizeFormatPlugin: ()=>NormalizeFormatPlugin,
+    IssueLinkRefsPlugin: ()=>IssueLinkRefsPlugin,
+    MergeSectionsPlugin: ()=>MergeSectionsPlugin,
+    ContentStructureRule: ()=>ContentStructureRule,
+    HeadingHierarchyRule: ()=>HeadingHierarchyRule,
+    DeduplicateItemsPlugin: ()=>DeduplicateItemsPlugin,
+    ReorderSectionsPlugin: ()=>ReorderSectionsPlugin,
+    ContributorFootnotesPlugin: ()=>ContributorFootnotesPlugin,
+    SilkChangesetPreset: ()=>SilkChangesetPreset,
+    RequiredSectionsRule: ()=>RequiredSectionsRule
+});
+const external_unist_util_visit_namespaceObject = require("unist-util-visit");
+const external_mdast_util_to_string_namespaceObject = require("mdast-util-to-string");
+function getVersionBlocks(tree) {
+    const blocks = [];
+    for(let i = 0; i < tree.children.length; i++){
+        const node = tree.children[i];
+        if ("heading" === node.type && 2 === node.depth) blocks.push({
+            headingIndex: i,
+            startIndex: i + 1,
+            endIndex: tree.children.length
+        });
+    }
+    for(let i = 0; i < blocks.length - 1; i++)blocks[i].endIndex = blocks[i + 1].headingIndex;
+    return blocks;
+}
+function getBlockSections(tree, block) {
+    const sections = [];
+    for(let i = block.startIndex; i < block.endIndex; i++){
+        const node = tree.children[i];
+        if ("heading" === node.type && 3 === node.depth) sections.push({
+            heading: node,
+            headingIndex: i,
+            contentNodes: []
+        });
+        else if (sections.length > 0) sections[sections.length - 1].contentNodes.push(node);
+    }
+    return sections;
+}
+function getHeadingText(heading) {
+    return (0, external_mdast_util_to_string_namespaceObject.toString)(heading);
+}
+const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
+function extractLinkedAttribution(children) {
+    if (children.length < 3) return;
+    const last = children[children.length - 1];
+    const secondLast = children[children.length - 2];
+    const thirdLast = children[children.length - 3];
+    if ("text" !== last.type || "!" !== last.value) return;
+    if ("link" !== secondLast.type) return;
+    const linkNode = secondLast;
+    if (1 !== linkNode.children.length || "text" !== linkNode.children[0].type) return;
+    const linkText = linkNode.children[0].value;
+    if (!linkText.startsWith("@")) return;
+    const username = linkText.slice(1);
+    if ("text" !== thirdLast.type) return;
+    const textNode = thirdLast;
+    if (!/\s*Thanks $/.test(textNode.value)) return;
+    return {
+        contributor: {
+            username,
+            url: linkNode.url
+        },
+        removeFrom: children.length - 3
+    };
+}
+const ContributorFootnotesPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for(let b = blocks.length - 1; b >= 0; b--){
+            const block = blocks[b];
+            const contributors = new Map();
+            for(let i = block.startIndex; i < block.endIndex; i++){
+                const node = tree.children[i];
+                if ("list" === node.type) (0, external_unist_util_visit_namespaceObject.visit)(node, "paragraph", (para)=>{
+                    const linked = extractLinkedAttribution(para.children);
+                    if (linked) {
+                        const key = linked.contributor.username.toLowerCase();
+                        if (!contributors.has(key)) contributors.set(key, linked.contributor);
+                        const textNode = para.children[linked.removeFrom];
+                        textNode.value = textNode.value.replace(/\s*Thanks $/, "");
+                        para.children.splice(linked.removeFrom + 1, 2);
+                        if ("" === textNode.value) para.children.splice(linked.removeFrom, 1);
+                        return;
+                    }
+                    const last = para.children[para.children.length - 1];
+                    if (last?.type === "text") {
+                        const textNode = last;
+                        const match = textNode.value.match(ATTRIBUTION_PLAIN_RE);
+                        if (match) {
+                            const username = match[1];
+                            const key = username.toLowerCase();
+                            if (!contributors.has(key)) contributors.set(key, {
+                                username,
+                                url: void 0
+                            });
+                            textNode.value = textNode.value.replace(ATTRIBUTION_PLAIN_RE, "");
+                        }
+                    }
+                });
+            }
+            if (0 === contributors.size) continue;
+            const sorted = [
+                ...contributors.values()
+            ].sort((a, b)=>a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
+            const phrasingChildren = [];
+            phrasingChildren.push({
+                type: "text",
+                value: "Thanks to "
+            });
+            for(let i = 0; i < sorted.length; i++){
+                const contrib = sorted[i];
+                if (i > 0 && sorted.length > 2) phrasingChildren.push({
+                    type: "text",
+                    value: ", "
+                });
+                if (i > 0 && i === sorted.length - 1) phrasingChildren.push({
+                    type: "text",
+                    value: 2 === sorted.length ? " and " : "and "
+                });
+                if (contrib.url) phrasingChildren.push({
+                    type: "link",
+                    url: contrib.url,
+                    children: [
+                        {
+                            type: "text",
+                            value: `@${contrib.username}`
+                        }
+                    ]
+                });
+                else phrasingChildren.push({
+                    type: "text",
+                    value: `@${contrib.username}`
+                });
+            }
+            phrasingChildren.push({
+                type: "text",
+                value: " for their contributions!"
+            });
+            const paragraph = {
+                type: "paragraph",
+                children: phrasingChildren
+            };
+            tree.children.splice(block.endIndex, 0, paragraph);
+        }
+    };
+const DeduplicateItemsPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for (const block of blocks){
+            const sections = getBlockSections(tree, block);
+            for (const section of sections)for (const node of section.contentNodes){
+                if ("list" !== node.type) continue;
+                const list = node;
+                const seen = new Set();
+                list.children = list.children.filter((item)=>{
+                    const text = (0, external_mdast_util_to_string_namespaceObject.toString)(item);
+                    if (seen.has(text)) return false;
+                    seen.add(text);
+                    return true;
+                });
+            }
+        }
+        tree.children = tree.children.filter((node)=>{
+            if ("list" === node.type) return node.children.length > 0;
+            return true;
+        });
+    };
+const ISSUE_RE = /^#\d+$/;
+const IssueLinkRefsPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for(let b = blocks.length - 1; b >= 0; b--){
+            const block = blocks[b];
+            const definitions = new Map();
+            for(let i = block.startIndex; i < block.endIndex; i++){
+                const node = tree.children[i];
+                (0, external_unist_util_visit_namespaceObject.visit)(node, "link", (linkNode, index, parent)=>{
+                    if (!parent || void 0 === index) return;
+                    if (1 !== linkNode.children.length || "text" !== linkNode.children[0].type) return;
+                    const text = linkNode.children[0].value;
+                    if (!ISSUE_RE.test(text)) return;
+                    const label = text;
+                    if (!definitions.has(label)) definitions.set(label, {
+                        label,
+                        url: linkNode.url
+                    });
+                    const ref = {
+                        type: "linkReference",
+                        identifier: label,
+                        label,
+                        referenceType: "full",
+                        children: [
+                            {
+                                type: "text",
+                                value: label
+                            }
+                        ]
+                    };
+                    parent.children[index] = ref;
+                    return external_unist_util_visit_namespaceObject.SKIP;
+                });
+            }
+            if (0 === definitions.size) continue;
+            const sorted = [
+                ...definitions.values()
+            ].sort((a, b)=>{
+                const aNum = Number.parseInt(a.label.slice(1), 10);
+                const bNum = Number.parseInt(b.label.slice(1), 10);
+                return aNum - bNum;
+            });
+            const defNodes = sorted.map((def)=>({
+                    type: "definition",
+                    identifier: def.label,
+                    label: def.label,
+                    url: def.url
+                }));
+            tree.children.splice(block.endIndex, 0, ...defNodes);
+        }
+    };
+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 fromHeading(heading) {
+    return headingToCategory.get(heading.toLowerCase());
+}
+function isValidHeading(heading) {
+    return headingToCategory.has(heading.toLowerCase());
+}
+function allHeadings() {
+    return CATEGORIES.map((cat)=>cat.heading);
+}
+const MergeSectionsPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for(let b = blocks.length - 1; b >= 0; b--){
+            const sections = getBlockSections(tree, blocks[b]);
+            if (sections.length <= 1) continue;
+            const groups = new Map();
+            for(let s = 0; s < sections.length; s++){
+                const text = getHeadingText(sections[s].heading);
+                const category = fromHeading(text);
+                const key = category ? category.heading.toLowerCase() : text.toLowerCase();
+                const existing = groups.get(key);
+                if (existing) existing.push(s);
+                else groups.set(key, [
+                    s
+                ]);
+            }
+            const indicesToRemove = [];
+            for (const indices of groups.values()){
+                if (indices.length <= 1) continue;
+                const target = sections[indices[0]];
+                const targetEndIndex = target.headingIndex + 1 + target.contentNodes.length;
+                const mergedContent = [];
+                for(let d = 1; d < indices.length; d++){
+                    const dup = sections[indices[d]];
+                    mergedContent.push(...dup.contentNodes);
+                    indicesToRemove.push(dup.headingIndex);
+                    for(let c = 0; c < dup.contentNodes.length; c++)indicesToRemove.push(dup.headingIndex + 1 + c);
+                }
+                tree.children.splice(targetEndIndex, 0, ...mergedContent);
+                const shift = mergedContent.length;
+                for(let r = 0; r < indicesToRemove.length; r++)if (indicesToRemove[r] >= targetEndIndex) indicesToRemove[r] += shift;
+            }
+            indicesToRemove.sort((a, b)=>b - a);
+            for (const idx of indicesToRemove)tree.children.splice(idx, 1);
+        }
+    };
+function isHeadingAtDepth(node, depths) {
+    return "heading" === node.type && depths.includes(node.depth);
+}
+const NormalizeFormatPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        const indicesToRemove = new Set();
+        for (const block of blocks)for(let i = block.startIndex; i < block.endIndex; i++){
+            const node = tree.children[i];
+            if ("list" === node.type && 0 === node.children.length) {
+                indicesToRemove.add(i);
+                continue;
+            }
+            if (!isHeadingAtDepth(node, [
+                3
+            ])) continue;
+            let hasContent = false;
+            for(let j = i + 1; j < block.endIndex; j++){
+                const next = tree.children[j];
+                if ("paragraph" === next.type && "" === (0, external_mdast_util_to_string_namespaceObject.toString)(next).trim()) {
+                    indicesToRemove.add(j);
+                    continue;
+                }
+                if (isHeadingAtDepth(next, [
+                    2,
+                    3
+                ])) break;
+                hasContent = true;
+                break;
+            }
+            if (!hasContent) indicesToRemove.add(i);
+        }
+        const sorted = [
+            ...indicesToRemove
+        ].sort((a, b)=>b - a);
+        for (const idx of sorted)tree.children.splice(idx, 1);
+    };
+const UNKNOWN_PRIORITY = 999;
+const ReorderSectionsPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for(let b = blocks.length - 1; b >= 0; b--){
+            const block = blocks[b];
+            const sections = getBlockSections(tree, block);
+            if (sections.length <= 1) continue;
+            const preamble = [];
+            for(let i = block.startIndex; i < block.endIndex; i++)if (i < sections[0].headingIndex) preamble.push(tree.children[i]);
+            else break;
+            const sorted = [
+                ...sections
+            ].sort((a, b)=>{
+                const aPriority = fromHeading(getHeadingText(a.heading))?.priority ?? UNKNOWN_PRIORITY;
+                const bPriority = fromHeading(getHeadingText(b.heading))?.priority ?? UNKNOWN_PRIORITY;
+                return aPriority - bPriority;
+            });
+            const alreadySorted = sorted.every((s, i)=>s.headingIndex === sections[i].headingIndex);
+            if (alreadySorted) continue;
+            const newChildren = [
+                ...preamble
+            ];
+            for (const section of sorted)newChildren.push(section.heading, ...section.contentNodes);
+            const blockLength = block.endIndex - block.startIndex;
+            tree.children.splice(block.startIndex, blockLength, ...newChildren);
+        }
+    };
+const external_unified_lint_rule_namespaceObject = require("unified-lint-rule");
+const ContentStructureRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-content-structure", (tree, file)=>{
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node, index, parent)=>{
+        if (2 !== node.depth || null == parent || null == index) return;
+        const next = parent.children[index + 1];
+        if (!next || "heading" === next.type && 2 === next.depth) file.message("Empty section: heading has no content before the next section or end of file", node);
+    });
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "code", (node)=>{
+        if (!node.lang) file.message("Code block is missing a language identifier", node);
+    });
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "listItem", (node)=>{
+        const text = (0, external_mdast_util_to_string_namespaceObject.toString)(node).trim();
+        if (!text) file.message("Empty list item", node);
+    });
+});
+const HeadingHierarchyRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-heading-hierarchy", (tree, file)=>{
+    let prevDepth = 0;
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node)=>{
+        if (1 === node.depth) return void file.message("h1 headings are not allowed in changeset files", node);
+        if (prevDepth > 0 && node.depth > prevDepth + 1) file.message(`Heading level skipped: expected h${prevDepth + 1} or lower, found h${node.depth}`, node);
+        prevDepth = node.depth;
+    });
+});
+const RequiredSectionsRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-required-sections", (tree, file)=>{
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node)=>{
+        if (2 !== node.depth) return;
+        const text = (0, external_mdast_util_to_string_namespaceObject.toString)(node);
+        if (!isValidHeading(text)) file.message(`Unknown section "${text}". Valid sections: ${allHeadings().join(", ")}`, node);
+    });
+});
+const SilkChangesetPreset = [
+    HeadingHierarchyRule,
+    RequiredSectionsRule,
+    ContentStructureRule
+];
+const SilkChangesetTransformPreset = [
+    MergeSectionsPlugin,
+    ReorderSectionsPlugin,
+    DeduplicateItemsPlugin,
+    ContributorFootnotesPlugin,
+    IssueLinkRefsPlugin,
+    NormalizeFormatPlugin
+];
+exports.ContentStructureRule = __webpack_exports__.ContentStructureRule;
+exports.ContributorFootnotesPlugin = __webpack_exports__.ContributorFootnotesPlugin;
+exports.DeduplicateItemsPlugin = __webpack_exports__.DeduplicateItemsPlugin;
+exports.HeadingHierarchyRule = __webpack_exports__.HeadingHierarchyRule;
+exports.IssueLinkRefsPlugin = __webpack_exports__.IssueLinkRefsPlugin;
+exports.MergeSectionsPlugin = __webpack_exports__.MergeSectionsPlugin;
+exports.NormalizeFormatPlugin = __webpack_exports__.NormalizeFormatPlugin;
+exports.ReorderSectionsPlugin = __webpack_exports__.ReorderSectionsPlugin;
+exports.RequiredSectionsRule = __webpack_exports__.RequiredSectionsRule;
+exports.SilkChangesetPreset = __webpack_exports__.SilkChangesetPreset;
+exports.SilkChangesetTransformPreset = __webpack_exports__.SilkChangesetTransformPreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ContentStructureRule",
+    "ContributorFootnotesPlugin",
+    "DeduplicateItemsPlugin",
+    "HeadingHierarchyRule",
+    "IssueLinkRefsPlugin",
+    "MergeSectionsPlugin",
+    "NormalizeFormatPlugin",
+    "ReorderSectionsPlugin",
+    "RequiredSectionsRule",
+    "SilkChangesetPreset",
+    "SilkChangesetTransformPreset"
+].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;
+}