@claudian-collab/protocol 3.2.0 → 3.2.1

package/dist/esm/CollabError.mjs

@@ -0,0 +1,175 @@
+export const COLLAB_ERROR_CODES = Object.freeze([
+    'protocol-version-unsupported',
+    'protocol-payload-invalid',
+    'project-not-found',
+    'quota-exceeded',
+    'authentication-failed',
+    'authorization-denied',
+    'membership-revoked',
+    'stale-main',
+    'stale-request-head',
+    'personal-ref-diverged',
+    'content-conflict',
+    'description-required',
+    'request-not-open',
+    'request-head-not-pushed',
+    'ticket-not-found',
+    'resolving-ticket-reference-not-found',
+    'ticket-not-open',
+    'stale-ticket',
+    'stale-request-metadata',
+    'authority-not-synchronized',
+    'authority-transfer-not-found',
+    'authority-transfer-stale',
+    'authority-transfer-cancellation-forbidden',
+    'membership-claim-invalid',
+    'membership-claim-expired',
+    'membership-claim-revoked',
+    'membership-claim-already-redeemed',
+    'project-retired',
+    'idempotency-conflict',
+    'acceptance-recovery-required',
+    'authority-integrity-error',
+    'operation-timeout',
+    'operation-failed',
+]);
+const COLLAB_RECOVERY_ACTIONS = Object.freeze([
+    'retry',
+    'review-conflicts',
+    'request-access',
+]);
+const COLLAB_ERROR_CODE_SET = new Set(COLLAB_ERROR_CODES);
+const COLLAB_RECOVERY_ACTION_SET = new Set(COLLAB_RECOVERY_ACTIONS);
+const SAFE_CONTEXT_RULES = Object.freeze({
+    endpoint: 'path',
+    exitCode: 'number',
+    field: 'token',
+    kind: 'token',
+    limit: 'number',
+    operation: 'token',
+    operationId: 'id',
+    path: 'path',
+    projectId: 'id',
+    quota: 'token',
+    reason: 'token',
+    receivedVersion: 'number',
+    recordKind: 'token',
+    retiredAt: 'timestamp',
+    side: 'token',
+    status: 'token',
+    supportedVersion: 'number',
+    ticketNumber: 'number',
+});
+const SAFE_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SAFE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+function sanitizeAllowedValue(rule, value) {
+    switch (rule) {
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value) ? value : null;
+        case 'path':
+            return typeof value === 'string' ? '[PATH]' : null;
+        case 'timestamp':
+            return typeof value === 'string'
+                && !Number.isNaN(Date.parse(value))
+                && new Date(value).toISOString() === value
+                ? value
+                : null;
+        case 'id':
+            return typeof value === 'string' && SAFE_ID_PATTERN.test(value) ? value : null;
+        case 'token':
+            return typeof value === 'string' && SAFE_TOKEN_PATTERN.test(value) ? value : null;
+    }
+}
+export function sanitizeCollabDiagnosticContext(context = {}) {
+    const result = {};
+    for (const [key, value] of Object.entries(context)) {
+        const rule = SAFE_CONTEXT_RULES[key];
+        if (!rule)
+            continue;
+        const sanitized = sanitizeAllowedValue(rule, value);
+        if (sanitized !== null)
+            result[key] = sanitized;
+    }
+    return result;
+}
+export function collabErrorGroup(code) {
+    switch (code) {
+        case 'protocol-version-unsupported':
+        case 'protocol-payload-invalid':
+            return 'setup';
+        case 'project-not-found':
+        case 'authority-transfer-not-found':
+        case 'quota-exceeded':
+            return 'path';
+        case 'authentication-failed':
+        case 'authorization-denied':
+        case 'membership-revoked':
+        case 'membership-claim-invalid':
+        case 'membership-claim-expired':
+        case 'membership-claim-revoked':
+            return 'authorization';
+        case 'stale-main':
+        case 'stale-request-head':
+        case 'personal-ref-diverged':
+        case 'content-conflict':
+        case 'description-required':
+        case 'request-not-open':
+        case 'request-head-not-pushed':
+        case 'ticket-not-found':
+        case 'resolving-ticket-reference-not-found':
+        case 'ticket-not-open':
+        case 'stale-ticket':
+        case 'stale-request-metadata':
+        case 'authority-not-synchronized':
+        case 'authority-transfer-stale':
+        case 'authority-transfer-cancellation-forbidden':
+        case 'membership-claim-already-redeemed':
+        case 'project-retired':
+        case 'idempotency-conflict':
+            return 'state';
+        case 'acceptance-recovery-required':
+        case 'authority-integrity-error':
+            return 'integrity';
+        case 'operation-timeout':
+        case 'operation-failed':
+            return 'operation';
+    }
+}
+export class CollabError extends Error {
+    code;
+    group;
+    safeContext;
+    recoveryActions;
+    constructor(options) {
+        if (!COLLAB_ERROR_CODE_SET.has(options.code)) {
+            throw new TypeError('Unsupported Collab error code');
+        }
+        if (!(options.recoveryActions ?? []).every(action => COLLAB_RECOVERY_ACTION_SET.has(action))) {
+            throw new TypeError('Unsupported Collab recovery action');
+        }
+        super(`collab.error.${options.code}`);
+        this.name = 'CollabError';
+        this.code = options.code;
+        this.group = collabErrorGroup(options.code);
+        this.safeContext = Object.freeze(sanitizeCollabDiagnosticContext(options.safeContext));
+        this.recoveryActions = Object.freeze([...(options.recoveryActions ?? [])]);
+        if (options.cause !== undefined) {
+            Object.defineProperty(this, 'cause', {
+                configurable: false,
+                enumerable: false,
+                value: options.cause,
+                writable: false,
+            });
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            group: this.group,
+            message: this.message,
+            safeContext: this.safeContext,
+            recoveryActions: this.recoveryActions,
+        };
+    }
+}

package/dist/esm/CollabMarkdownProse.mjs

@@ -0,0 +1,54 @@
+import { parser } from '@lezer/markdown';
+const MASKED_MARKDOWN_NODES = new Set([
+    'CodeBlock',
+    'Comment',
+    'CommentBlock',
+    'FencedCode',
+    'HTMLBlock',
+    'HTMLTag',
+    'Image',
+    'InlineCode',
+    'LinkLabel',
+    'LinkReference',
+    'LinkTitle',
+    'ProcessingInstruction',
+    'ProcessingInstructionBlock',
+    'URL',
+]);
+const BOUNDARY_MASKED_MARKDOWN_NODES = new Set(['Entity']);
+export function maskCollabMarkdownProse(markdown) {
+    const maskedRanges = [];
+    const escapes = [];
+    parser.parse(markdown).iterate({
+        enter(node) {
+            if (node.name === 'Escape') {
+                escapes.push({ from: node.from, to: node.to });
+                return false;
+            }
+            if (MASKED_MARKDOWN_NODES.has(node.name)
+                || BOUNDARY_MASKED_MARKDOWN_NODES.has(node.name)) {
+                maskedRanges.push({
+                    from: node.from,
+                    preservesBoundary: BOUNDARY_MASKED_MARKDOWN_NODES.has(node.name),
+                    to: node.to,
+                });
+                return false;
+            }
+            return true;
+        },
+    });
+    const output = markdown.split('');
+    for (const range of maskedRanges) {
+        for (let offset = range.from; offset < range.to; offset += 1) {
+            if (markdown[offset] !== '\n' && markdown[offset] !== '\r') {
+                output[offset] = range.preservesBoundary ? '_' : ' ';
+            }
+        }
+    }
+    for (const escape of escapes) {
+        const escaped = markdown.slice(escape.from + 1, escape.to);
+        output[escape.from] = ' ';
+        output[escape.from + 1] = escaped === '@' || escaped === '#' ? '_' : escaped;
+    }
+    return output.join('');
+}

package/dist/esm/CollabMemberMentionParser.mjs

@@ -0,0 +1,48 @@
+import { maskCollabMarkdownProse } from './CollabMarkdownProse.mjs';
+const MENTION_ADJACENT_CHARACTER = /[\p{L}\p{N}_@-]/u;
+export function parseCollabMemberMentions(markdown, targets) {
+    const candidates = mentionCandidates(targets);
+    if (candidates.length === 0)
+        return [];
+    const prose = maskCollabMarkdownProse(markdown);
+    const memberIds = new Set();
+    let searchFrom = 0;
+    while (searchFrom < prose.length) {
+        const mentionStart = prose.indexOf('@', searchFrom);
+        if (mentionStart < 0)
+            break;
+        searchFrom = mentionStart + 1;
+        const preceding = prose[mentionStart - 1];
+        if (preceding !== undefined && MENTION_ADJACENT_CHARACTER.test(preceding))
+            continue;
+        const candidate = candidates.find(entry => {
+            if (!prose.startsWith(entry.name, mentionStart + 1))
+                return false;
+            const following = prose[mentionStart + entry.name.length + 1];
+            return following === undefined || !MENTION_ADJACENT_CHARACTER.test(following);
+        });
+        if (!candidate)
+            continue;
+        memberIds.add(candidate.memberId);
+        searchFrom = mentionStart + candidate.name.length + 1;
+    }
+    return [...memberIds];
+}
+function mentionCandidates(targets) {
+    const byName = new Map();
+    for (const target of targets) {
+        const name = target.displayName.trim();
+        if (name.length === 0)
+            continue;
+        const existing = byName.get(name);
+        if (existing === undefined) {
+            byName.set(name, { memberId: target.memberId, name });
+        }
+        else if (existing?.memberId !== target.memberId) {
+            byName.set(name, null);
+        }
+    }
+    return [...byName.values()]
+        .filter((candidate) => candidate !== null)
+        .sort((left, right) => right.name.length - left.name.length);
+}