@magland/mochi 0.3.1

package/dist/issues.js

@@ -0,0 +1,308 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISSUE_SORTS = exports.MAX_LABELS = exports.MAX_TITLE = exports.MAX_BODY = void 0;
+exports.issuesDir = issuesDir;
+exports.listIssues = listIssues;
+exports.listIssuesAndMatches = listIssuesAndMatches;
+exports.selectIssues = selectIssues;
+exports.labelsInUse = labelsInUse;
+exports.authorsInUse = authorsInUse;
+exports.issueCounts = issueCounts;
+exports.readIssue = readIssue;
+exports.checkLabels = checkLabels;
+exports.createIssue = createIssue;
+exports.addComment = addComment;
+exports.setIssueState = setIssueState;
+exports.editIssue = editIssue;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const discussion_1 = require("./discussion");
+const ops_1 = require("./ops");
+const layout_1 = require("./layout");
+const scan_1 = require("./scan");
+var discussion_2 = require("./discussion");
+Object.defineProperty(exports, "MAX_BODY", { enumerable: true, get: function () { return discussion_2.MAX_BODY; } });
+Object.defineProperty(exports, "MAX_TITLE", { enumerable: true, get: function () { return discussion_2.MAX_TITLE; } });
+exports.MAX_LABELS = 10;
+/** The issues directory for a repository, whether or not it exists yet. */
+function issuesDir(root, collection, repo) {
+    if (!(0, scan_1.isValidName)(collection) || !(0, scan_1.isValidName)(repo))
+        return null;
+    return (0, layout_1.repoPath)(root, collection, `${(0, scan_1.displayName)(repo)}.issues`);
+}
+const ISSUE = {
+    doc: 'issue.md',
+    indefinite: 'an issue',
+    Indefinite: 'An issue',
+    Bare: 'Issue',
+    dirFor: issuesDir,
+};
+/** Move the issues directory's timestamp, invalidating the count cache. */
+function touchIssues(root, collection, repo) {
+    const dir = issuesDir(root, collection, repo);
+    if (dir)
+        (0, discussion_1.touch)(dir);
+}
+function issueDir(root, collection, repo, n) {
+    return (0, discussion_1.itemDir)(ISSUE, root, collection, repo, n);
+}
+function labelsOf(v) {
+    if (Array.isArray(v))
+        return v.filter((x) => typeof x === 'string');
+    if (typeof v === 'string')
+        return v.split(',').map((s) => s.trim()).filter((s) => s !== '');
+    return [];
+}
+function summaryFrom(n, dir, doc) {
+    const created = (0, discussion_1.str)(doc.meta.created);
+    return {
+        number: n,
+        title: (0, discussion_1.str)(doc.meta.title, `Issue ${n}`),
+        state: doc.meta.state === 'closed' ? 'closed' : 'open',
+        author: (0, discussion_1.str)(doc.meta.author, 'unknown'),
+        created,
+        updated: (0, discussion_1.str)(doc.meta.updated, created),
+        labels: labelsOf(doc.meta.labels),
+        comments: (0, discussion_1.countComments)(dir),
+        closedBy: doc.meta.closedBy === undefined ? undefined : (0, discussion_1.str)(doc.meta.closedBy),
+        closedAt: doc.meta.closedAt === undefined ? undefined : (0, discussion_1.str)(doc.meta.closedAt),
+    };
+}
+/**
+ * Every issue in a repository, newest first. A `match` narrows the list while
+ * the files are being read, which is where the body is in hand: searching
+ * titles alone would miss the issue whose subject is in its first paragraph,
+ * and reading every file twice to find it would be silly.
+ */
+/** Read every issue once, handing each to `visit` with its body. */
+function scanIssues(root, collection, repo, visit) {
+    const dir = issuesDir(root, collection, repo);
+    if (!dir)
+        return;
+    for (const n of (0, discussion_1.numericDirs)(dir)) {
+        const sub = path.join(dir, String(n));
+        const doc = (0, discussion_1.readDoc)(path.join(sub, 'issue.md'));
+        if (!doc)
+            continue;
+        visit(summaryFrom(n, sub, doc), doc.body);
+    }
+}
+/** Whether a reader's query, already lowercased and trimmed, finds an issue. */
+function matchesQuery(summary, body, needle) {
+    if (needle === '')
+        return true;
+    return (summary.title.toLowerCase().includes(needle) ||
+        body.toLowerCase().includes(needle) ||
+        summary.labels.some((l) => l.toLowerCase().includes(needle)));
+}
+// Newest first, which is how a list of issues is read.
+const newestFirst = (a, b) => b.number - a.number;
+function listIssues(root, collection, repo, opts = {}) {
+    const needle = (opts.match ?? '').trim().toLowerCase();
+    const out = [];
+    scanIssues(root, collection, repo, (summary, body) => {
+        if (matchesQuery(summary, body, needle))
+            out.push(summary);
+    });
+    return out.sort(newestFirst);
+}
+/**
+ * Every issue, and the ones a query finds, from one pass over the directory.
+ *
+ * The list page needs both, because the tab counts and the label and author
+ * menus are of the whole repository while the rows are of the query. Asking
+ * listIssues twice read and YAML-parsed every issue twice -- and that parse is
+ * nine tenths of what the page costs -- so the query is applied here instead,
+ * while the issue is already in hand. No body is kept afterwards.
+ */
+function listIssuesAndMatches(root, collection, repo, query) {
+    const needle = query.trim().toLowerCase();
+    const all = [];
+    const matched = [];
+    scanIssues(root, collection, repo, (summary, body) => {
+        all.push(summary);
+        if (matchesQuery(summary, body, needle))
+            matched.push(summary);
+    });
+    return { all: all.sort(newestFirst), matched: matched.sort(newestFirst) };
+}
+exports.ISSUE_SORTS = [
+    { key: 'newest', label: 'Newest' },
+    { key: 'oldest', label: 'Oldest' },
+    { key: 'updated', label: 'Recently updated' },
+    { key: 'comments', label: 'Most commented' },
+];
+/** Narrow and order a list that has already been read. */
+function selectIssues(list, opts) {
+    const state = opts.state ?? 'open';
+    const out = list.filter((i) => (state === 'all' || i.state === state) &&
+        (!opts.label || i.labels.includes(opts.label)) &&
+        (!opts.author || i.author === opts.author));
+    const by = {
+        newest: (a, b) => b.number - a.number,
+        oldest: (a, b) => a.number - b.number,
+        updated: (a, b) => (a.updated < b.updated ? 1 : a.updated > b.updated ? -1 : 0),
+        comments: (a, b) => b.comments - a.comments || b.number - a.number,
+    };
+    return out.sort(by[opts.sort ?? 'newest']);
+}
+/** Every label in use, and how many issues carry it. */
+function labelsInUse(list) {
+    const counts = new Map();
+    for (const issue of list) {
+        for (const label of issue.labels)
+            counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([label, count]) => ({ label, count }))
+        .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+}
+/** Everyone who has opened an issue, most prolific first. */
+function authorsInUse(list) {
+    const counts = new Map();
+    for (const issue of list)
+        counts.set(issue.author, (counts.get(issue.author) ?? 0) + 1);
+    return [...counts.entries()]
+        .map(([author, count]) => ({ author, count }))
+        .sort((a, b) => b.count - a.count || a.author.localeCompare(b.author));
+}
+// Counting open issues means reading every issue's header, and the Issues tab
+// asks for that count on every page of a repository. So the answer is
+// memoized against the issues directory's modification time, and every write
+// below touches that directory - including a state change inside a
+// subdirectory, which would not otherwise move it. One read per change rather
+// than one per page view, and a vault with no issues never pays anything.
+const countMemo = new Map();
+/** Open and closed counts, for the tab and the list's filter. */
+function issueCounts(root, collection, repo) {
+    const dir = issuesDir(root, collection, repo);
+    if (!dir)
+        return { open: 0, closed: 0 };
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(dir).mtimeMs;
+    }
+    catch {
+        return { open: 0, closed: 0 };
+    }
+    const cached = countMemo.get(dir);
+    if (cached && cached.mtimeMs === mtimeMs)
+        return cached.counts;
+    const counts = { open: 0, closed: 0 };
+    for (const issue of listIssues(root, collection, repo)) {
+        if (issue.state === 'open')
+            counts.open++;
+        else
+            counts.closed++;
+    }
+    if (countMemo.size > 2000)
+        countMemo.clear();
+    countMemo.set(dir, { mtimeMs, counts });
+    return counts;
+}
+function readIssue(root, collection, repo, n) {
+    const dir = issueDir(root, collection, repo, n);
+    if (!dir)
+        return null;
+    const doc = (0, discussion_1.readDoc)(path.join(dir, 'issue.md'));
+    if (!doc)
+        return null;
+    return { ...summaryFrom(n, dir, doc), body: doc.body, commentList: (0, discussion_1.readComments)(dir) };
+}
+function checkLabels(labels) {
+    const out = [];
+    for (const raw of labels) {
+        const label = raw.trim();
+        if (label === '')
+            continue;
+        if (!/^[A-Za-z0-9][A-Za-z0-9 ._-]{0,29}$/.test(label))
+            throw new ops_1.OpError(`"${label}" is not a usable label.`);
+        if (!out.includes(label))
+            out.push(label);
+    }
+    if (out.length > exports.MAX_LABELS)
+        throw new ops_1.OpError(`An issue may carry at most ${exports.MAX_LABELS} labels.`);
+    return out;
+}
+function createIssue(root, collection, repo, input) {
+    const dir = issuesDir(root, collection, repo);
+    if (!dir)
+        throw new ops_1.OpError('invalid collection or repository name');
+    const title = (0, discussion_1.checkTitle)(ISSUE, input.title);
+    const body = (0, discussion_1.checkBody)(ISSUE, input.body);
+    const labels = checkLabels(input.labels ?? []);
+    const now = new Date().toISOString();
+    const n = (0, discussion_1.allocate)(ISSUE, dir, (sub) => (0, discussion_1.writeDoc)(path.join(sub, 'issue.md'), { title, state: 'open', author: input.author, created: now, updated: now, labels }, body));
+    return {
+        number: n,
+        title,
+        state: 'open',
+        author: input.author,
+        created: now,
+        updated: now,
+        labels,
+        comments: 0,
+    };
+}
+function addComment(root, collection, repo, n, input) {
+    return (0, discussion_1.addComment)(ISSUE, root, collection, repo, n, input);
+}
+function setIssueState(root, collection, repo, n, state, actor) {
+    const { dir, doc } = (0, discussion_1.openFor)(ISSUE, root, collection, repo, n);
+    const now = new Date().toISOString();
+    const meta = { ...doc.meta, state, updated: now };
+    if (state === 'closed') {
+        meta.closedBy = actor;
+        meta.closedAt = now;
+    }
+    else {
+        delete meta.closedBy;
+        delete meta.closedAt;
+    }
+    (0, discussion_1.writeDoc)(path.join(dir, 'issue.md'), meta, doc.body);
+    touchIssues(root, collection, repo);
+}
+function editIssue(root, collection, repo, n, input) {
+    const { dir, doc } = (0, discussion_1.openFor)(ISSUE, root, collection, repo, n);
+    const meta = { ...doc.meta, updated: new Date().toISOString() };
+    if (input.title !== undefined)
+        meta.title = (0, discussion_1.checkTitle)(ISSUE, input.title);
+    if (input.labels !== undefined)
+        meta.labels = checkLabels(input.labels);
+    const body = input.body === undefined ? doc.body : (0, discussion_1.checkBody)(ISSUE, input.body);
+    (0, discussion_1.writeDoc)(path.join(dir, 'issue.md'), meta, body);
+    touchIssues(root, collection, repo);
+}