lagora-cli 1.1.0

package/dist/scripts/notifications-EU43SIEV.js

@@ -0,0 +1,624 @@
+import "./chunk-TJZVQYBL.js";
+
+// lib/server/notifications.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// lib/server/notification-events.ts
+var listenersByUserId = /* @__PURE__ */ new Map();
+function publishNotificationUpdates(userIds) {
+  for (const userId of new Set(userIds)) {
+    const listeners = listenersByUserId.get(userId);
+    if (!listeners) continue;
+    for (const listener of listeners) listener();
+  }
+}
+
+// lib/server/notification-store.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import path4 from "node:path";
+
+// lib/server/user-auth-crypto.ts
+var browserDeviceMaxAgeSeconds = 400 * 24 * 60 * 60;
+
+// lib/server/user-auth-files.ts
+import path2 from "node:path";
+
+// lib/server/user-auth-records.ts
+var legacyAccountScope = "hyperaccel";
+function publicUser(user) {
+  return {
+    id: user.id,
+    displayName: user.displayName,
+    displayNameKey: user.displayNameKey,
+    accountScope: user.accountScope,
+    principalSubject: user.principalSubject,
+    isActive: user.isActive,
+    createdAt: user.createdAt,
+    lastSeenAt: user.lastSeenAt
+  };
+}
+function parseUsers(values) {
+  return values.map(parseStoredUser).filter((user) => Boolean(user));
+}
+function parseStoredUser(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.displayName !== "string" || typeof value.displayNameKey !== "string" || value.passwordHash !== void 0 && typeof value.passwordHash !== "string" || typeof value.isActive !== "boolean" || typeof value.createdAt !== "string" || value.principalSubject !== void 0 && typeof value.principalSubject !== "string" || value.lastSeenAt !== void 0 && typeof value.lastSeenAt !== "string") {
+    return void 0;
+  }
+  const accountScope = normalizeStoredAccountScope(value.accountScope);
+  if (!accountScope) return void 0;
+  const principalSubject = normalizeStoredPrincipalSubject(value.principalSubject);
+  return {
+    id: value.id,
+    displayName: value.displayName,
+    displayNameKey: value.displayNameKey,
+    accountScope,
+    ...principalSubject ? { principalSubject } : {},
+    ...typeof value.passwordHash === "string" ? { passwordHash: value.passwordHash } : {},
+    isActive: value.isActive,
+    createdAt: value.createdAt,
+    ...value.lastSeenAt ? { lastSeenAt: value.lastSeenAt } : {}
+  };
+}
+function normalizeStoredAccountScope(value) {
+  if (value === void 0) return legacyAccountScope;
+  if (value === "admin" || value === "hyperaccel") return value;
+  if (typeof value === "string" && /^vendor:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(value)) return value;
+  return void 0;
+}
+function normalizeStoredPrincipalSubject(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  return normalized || void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// lib/server/native-auth-records.ts
+var nativeTokenScopes = {
+  notifications: "notifications",
+  cli: "cli"
+};
+var nativeTokenScope = nativeTokenScopes.notifications;
+
+// lib/server/user-auth-file-store.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+var LOCK_WAIT_MS = 1e4;
+var LOCK_STALE_MS = 6e4;
+var LOCK_POLL_MS = 25;
+async function readJsonArray(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    if (hasNodeCode(error, "ENOENT")) return [];
+    throw error;
+  }
+}
+async function withFileLock(filePath, callback) {
+  const lockPath = `${filePath}.lock`;
+  const owner = `${process.pid}-${randomUUID()}`;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < LOCK_WAIT_MS) {
+    const handle = await tryCreateLock(lockPath, owner);
+    if (handle) {
+      try {
+        return await callback();
+      } finally {
+        await handle.close();
+        await releaseLock(lockPath, owner);
+      }
+    }
+    await removeStaleLock(lockPath);
+    await delay(LOCK_POLL_MS);
+  }
+  throw new Error(`Timed out waiting for user auth file lock: ${lockPath}`);
+}
+async function tryCreateLock(lockPath, owner) {
+  try {
+    const handle = await open(lockPath, "wx");
+    await handle.writeFile(`${JSON.stringify({ owner, pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`);
+    return handle;
+  } catch (error) {
+    if (hasNodeCode(error, "ENOENT")) {
+      await mkdir(path.dirname(lockPath), { recursive: true });
+      return tryCreateLock(lockPath, owner);
+    }
+    if (hasNodeCode(error, "EEXIST")) return void 0;
+    throw error;
+  }
+}
+async function removeStaleLock(lockPath) {
+  try {
+    const details = await stat(lockPath);
+    if (Date.now() - details.mtimeMs <= LOCK_STALE_MS) return;
+    await rm(lockPath, { force: true });
+  } catch (error) {
+    if (hasNodeCode(error, "ENOENT")) return;
+    throw error;
+  }
+}
+async function releaseLock(lockPath, owner) {
+  try {
+    const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+    if (isRecord2(parsed) && parsed.owner === owner) await rm(lockPath, { force: true });
+  } catch (error) {
+    if (hasNodeCode(error, "ENOENT")) return;
+    throw error;
+  }
+}
+function hasNodeCode(error, code) {
+  return error instanceof Error && Reflect.get(error, "code") === code;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// lib/server/user-auth-files.ts
+function userAuthRoot() {
+  if (process.env.AGORA_AUTH_DIR?.trim()) return path2.resolve(process.env.AGORA_AUTH_DIR);
+  if (process.env.AGORA_SETTINGS_DIR?.trim()) return path2.join(path2.resolve(process.env.AGORA_SETTINGS_DIR), "auth");
+  return path2.join(
+    /*turbopackIgnore: true*/
+    process.cwd(),
+    ".local-data",
+    "auth"
+  );
+}
+async function readUsers() {
+  return withFileLock(usersPath(), async () => parseUsers(await readJsonArray(usersPath())));
+}
+function usersPath() {
+  return path2.join(userAuthRoot(), "users.json");
+}
+
+// lib/server/user-auth.ts
+var userSessionMaxAgeSeconds = 30 * 24 * 60 * 60;
+var sessionTtlMs = userSessionMaxAgeSeconds * 1e3;
+async function resolveUserByDisplayName(displayName, accountScope = legacyAccountScope, principalSubject) {
+  const normalizedName = displayName.trim();
+  if (!normalizedName) return void 0;
+  const normalizedScope = normalizeAccountScope(accountScope);
+  const normalizedSubject = normalizePrincipalSubject(principalSubject);
+  const user = (await readUsers()).find((item) => sameProfile(item, normalizedName, normalizedScope, normalizedSubject) && item.isActive);
+  return user ? publicUser(user) : void 0;
+}
+async function listUsersForAdmin() {
+  return (await readUsers()).map(publicUser);
+}
+function sameProfile(user, displayName, accountScope, principalSubject) {
+  return user.displayNameKey === displayNameKey(displayName) && user.accountScope === accountScope && user.principalSubject === principalSubject;
+}
+function accountScopeCanViewVendor(accountScope, vendorId) {
+  if (accountScope === "admin" || accountScope === "hyperaccel") return true;
+  return accountScope === `vendor:${vendorId ?? legacyAccountScope}`;
+}
+function normalizeAccountScope(accountScope) {
+  if (accountScope === "admin" || accountScope === "hyperaccel") return accountScope;
+  if (/^vendor:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(accountScope)) return accountScope;
+  throw new Error(`Invalid account scope: ${accountScope}`);
+}
+function normalizePrincipalSubject(principalSubject) {
+  return normalizeStoredPrincipalSubject(principalSubject);
+}
+function displayNameKey(displayName) {
+  return displayName.trim().toLocaleLowerCase();
+}
+
+// lib/server/notification-store-lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, open as open2, readFile as readFile2, rm as rm2, stat as stat2 } from "node:fs/promises";
+import path3 from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+var DEFAULT_LOCK_WAIT_MS = 1e4;
+var DEFAULT_LOCK_STALE_MS = 6e4;
+var LOCK_POLL_MS2 = 50;
+async function withNotificationStoreLock(root, callback) {
+  const lock = await acquireNotificationStoreLock(root);
+  try {
+    return await callback();
+  } finally {
+    await lock.release();
+  }
+}
+async function acquireNotificationStoreLock(root) {
+  const lockPath = path3.join(root, "notifications.lock");
+  const owner = `${process.pid}-${randomUUID2()}`;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < notificationLockWaitMs()) {
+    const handle = await tryCreateLock2(lockPath, owner);
+    if (handle) return lockHandle(lockPath, owner, handle);
+    await removeStaleLock2(lockPath);
+    await delay2(LOCK_POLL_MS2);
+  }
+  throw new Error(`Timed out waiting for notification store lock: ${lockPath}`);
+}
+async function tryCreateLock2(lockPath, owner) {
+  try {
+    const handle = await open2(lockPath, "wx");
+    await handle.writeFile(`${JSON.stringify({ owner, pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`);
+    return handle;
+  } catch (error) {
+    if (hasNodeCode2(error, "ENOENT")) {
+      await mkdir2(path3.dirname(lockPath), { recursive: true });
+      return await tryCreateLock2(lockPath, owner);
+    }
+    if (hasNodeCode2(error, "EEXIST")) return void 0;
+    throw error;
+  }
+}
+async function removeStaleLock2(lockPath) {
+  try {
+    const details = await stat2(lockPath);
+    if (Date.now() - details.mtimeMs <= notificationLockStaleMs()) return;
+    await rm2(lockPath, { force: true });
+  } catch (error) {
+    if (hasNodeCode2(error, "ENOENT")) return;
+    throw error;
+  }
+}
+function lockHandle(lockPath, owner, handle) {
+  return {
+    release: async () => {
+      await handle.close();
+      try {
+        const current = JSON.parse(await readFile2(lockPath, "utf8"));
+        if (isRecord3(current) && current.owner === owner) await rm2(lockPath, { force: true });
+      } catch (error) {
+        if (hasNodeCode2(error, "ENOENT")) return;
+        throw error;
+      }
+    }
+  };
+}
+function notificationLockWaitMs() {
+  return readPositiveInt(process.env.AGORA_NOTIFICATION_LOCK_WAIT_MS, DEFAULT_LOCK_WAIT_MS);
+}
+function notificationLockStaleMs() {
+  return readPositiveInt(process.env.AGORA_NOTIFICATION_LOCK_STALE_MS, DEFAULT_LOCK_STALE_MS);
+}
+function readPositiveInt(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasNodeCode2(error, code) {
+  return error instanceof Error && Reflect.get(error, "code") === code;
+}
+
+// lib/server/notification-store.ts
+async function readNotificationRecords() {
+  try {
+    const parsed = JSON.parse(await readFile3(notificationsPath(), "utf8"));
+    return Array.isArray(parsed) ? parsed.filter(isIssueNotification) : [];
+  } catch (error) {
+    if (hasNodeCode3(error, "ENOENT")) return [];
+    throw error;
+  }
+}
+async function updateNotificationRecords(callback) {
+  return await withNotificationStoreLock(notificationsRoot(), async () => {
+    const current = await readNotificationRecords();
+    const output = callback(current);
+    await writeNotificationRecords(output.next);
+    return output.result;
+  });
+}
+async function compactNotificationRecords() {
+}
+async function notificationStoreStatus() {
+  const statusError = await readStatusError();
+  const notifications = statusError.notifications;
+  const newest = notifications.toSorted(compareNewestFirst)[0];
+  return {
+    path: notificationsPath(),
+    totalCount: notifications.length,
+    unreadCount: notifications.filter((notification) => !notification.readAt).length,
+    lastCreatedAt: newest?.createdAt,
+    lastError: statusError.error ?? await readNotificationStoreError()
+  };
+}
+async function recordNotificationStoreError(context, error) {
+  try {
+    await mkdir3(notificationsRoot(), { recursive: true });
+    const payload = {
+      context,
+      message: error instanceof Error ? error.message : String(error),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFile2(notificationErrorPath(), `${JSON.stringify(payload, null, 2)}
+`, { mode: 384 });
+  } catch (writeError) {
+    if (writeError instanceof Error) return;
+    throw writeError;
+  }
+}
+async function clearNotificationStoreError() {
+  await rm3(notificationErrorPath(), { force: true });
+}
+function notificationsRoot() {
+  if (process.env.AGORA_NOTIFICATIONS_DIR?.trim()) return path4.resolve(process.env.AGORA_NOTIFICATIONS_DIR);
+  return path4.join(userAuthRoot(), "notifications");
+}
+function notificationsPath() {
+  return path4.join(notificationsRoot(), "notifications.json");
+}
+async function writeNotificationRecords(notifications) {
+  await mkdir3(notificationsRoot(), { recursive: true });
+  const target = notificationsPath();
+  const temp = `${target}.${process.pid}.${randomUUID3()}.tmp`;
+  await writeFile2(temp, `${JSON.stringify(notifications, null, 2)}
+`, { mode: 384 });
+  await rename2(temp, target);
+  await rm3(notificationErrorPath(), { force: true });
+}
+async function readNotificationStoreError() {
+  try {
+    const parsed = JSON.parse(await readFile3(notificationErrorPath(), "utf8"));
+    return isNotificationStoreError(parsed) ? parsed : void 0;
+  } catch (error) {
+    if (hasNodeCode3(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
+async function readStatusError() {
+  try {
+    return { notifications: await readNotificationRecords() };
+  } catch (error) {
+    const storeError = {
+      context: "notification_store_status",
+      message: error instanceof Error ? error.message : String(error),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await recordNotificationStoreError(storeError.context, error);
+    return { notifications: [], error: storeError };
+  }
+}
+function notificationErrorPath() {
+  return path4.join(notificationsRoot(), "last-error.json");
+}
+function compareNewestFirst(left, right) {
+  return createdAtMs(right) - createdAtMs(left);
+}
+function createdAtMs(notification) {
+  const timestamp = new Date(notification.createdAt).getTime();
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function isIssueNotification(value) {
+  if (!isRecord4(value)) return false;
+  return typeof value.id === "string" && typeof value.recipientUserId === "string" && (value.issueId === void 0 || typeof value.issueId === "string") && (value.eventId === void 0 || typeof value.eventId === "string") && typeof value.eventType === "string" && typeof value.title === "string" && typeof value.body === "string" && (value.linkUrl === void 0 || typeof value.linkUrl === "string") && (value.readAt === void 0 || typeof value.readAt === "string") && typeof value.createdAt === "string";
+}
+function isNotificationStoreError(value) {
+  return isRecord4(value) && typeof value.context === "string" && typeof value.message === "string" && typeof value.createdAt === "string";
+}
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasNodeCode3(error, code) {
+  return error instanceof Error && Reflect.get(error, "code") === code;
+}
+
+// lib/server/notifications.ts
+async function createIssueCreatedNotifications(issue, actorUserId) {
+  try {
+    const recipients = (await listUsersForAdmin()).filter((user) => user.isActive && user.id !== actorUserId && accountScopeCanViewVendor(user.accountScope, issue.creatorVendorId));
+    return await createNotifications(recipients.map((user) => notificationInput(user.id, issue, "issue_created", {
+      title: issue.title,
+      body: "\uC0C8 \uC774\uC288\uAC00 \uB4F1\uB85D\uB418\uC5C8\uC2B5\uB2C8\uB2E4"
+    })));
+  } catch (error) {
+    await recordNotificationStoreError("issue_created", error);
+    throw error;
+  }
+}
+async function createIssueChangeNotifications(input) {
+  try {
+    const recipientIds = await issueRecipientIds(input.issue, input.actorUserId);
+    return await createNotifications(recipientIds.map((recipientUserId) => notificationInput(recipientUserId, input.issue, input.eventType, {
+      eventId: input.eventId,
+      title: input.title ?? "\uC774\uC288\uC5D0 \uBCC0\uACBD\uC0AC\uD56D\uC774 \uC788\uC2B5\uB2C8\uB2E4",
+      body: input.body ?? input.issue.title
+    })));
+  } catch (error) {
+    await recordNotificationStoreError(input.eventType, error);
+    throw error;
+  }
+}
+async function createIssueDeletedNotifications(issue, actorUserId) {
+  try {
+    const recipientIds = await issueRecipientIds(issue, actorUserId);
+    return await createNotifications(recipientIds.map((recipientUserId) => ({
+      recipientUserId,
+      issueId: issue.id,
+      eventType: "issue_deleted",
+      title: "\uC774\uC288\uAC00 \uC0AD\uC81C\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+      body: issue.title,
+      linkUrl: "/"
+    })));
+  } catch (error) {
+    await recordNotificationStoreError("issue_deleted", error);
+    throw error;
+  }
+}
+async function createAdminTestNotification(recipientUserId) {
+  return await createNotifications([{
+    recipientUserId,
+    eventType: "admin_test",
+    title: "\uC54C\uB9BC \uD14C\uC2A4\uD2B8",
+    body: "\uAD00\uB9AC\uC790 \uC124\uC815\uC5D0\uC11C \uBCF4\uB0B8 \uD14C\uC2A4\uD2B8 \uC54C\uB9BC\uC785\uB2C8\uB2E4.",
+    linkUrl: "/settings?section=notifications#notifications"
+  }]);
+}
+async function createSiteAnnouncementNotifications(input) {
+  try {
+    const recipients = (await listUsersForAdmin()).filter((user) => user.isActive);
+    return await createNotifications(recipients.map((user) => ({
+      recipientUserId: user.id,
+      eventType: "site_announcement",
+      title: input.title,
+      body: input.body,
+      linkUrl: input.linkUrl
+    })));
+  } catch (error) {
+    await recordNotificationStoreError("site_announcement", error);
+    throw error;
+  }
+}
+async function createNotifications(inputs) {
+  if (inputs.length === 0) return [];
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const notifications = inputs.map((input) => ({
+    id: randomUUID4(),
+    recipientUserId: input.recipientUserId,
+    issueId: input.issueId,
+    eventId: input.eventId,
+    eventType: input.eventType,
+    title: input.title,
+    body: input.body,
+    linkUrl: input.linkUrl,
+    readAt: input.readAt,
+    createdAt: input.createdAt ?? createdAt
+  }));
+  await updateNotificationRecords((current) => ({
+    next: [...current, ...notifications],
+    result: void 0
+  }));
+  publishNotificationUpdates(notifications.map((notification) => notification.recipientUserId));
+  return notifications;
+}
+async function listNotificationsForUser(userId) {
+  return notificationsForUser(await readNotificationRecords(), userId);
+}
+async function unreadNotificationCount(userId) {
+  return (await listNotificationsForUser(userId)).filter((notification) => !notification.readAt).length;
+}
+async function markNotificationRead(userId, notificationId, now = /* @__PURE__ */ new Date()) {
+  const readAt = now.toISOString();
+  const result = await updateNotificationRecords((notifications2) => {
+    let found = false;
+    const next = notifications2.map((notification) => {
+      if (notification.recipientUserId !== userId || notification.id !== notificationId) return notification;
+      found = true;
+      return notification.readAt ? notification : { ...notification, readAt };
+    });
+    return {
+      next,
+      result: { found }
+    };
+  });
+  const notifications = await listNotificationsForUser(userId);
+  if (result.found) publishNotificationUpdates([userId]);
+  return result.found ? { kind: "updated", notifications } : { kind: "not_found", notifications };
+}
+async function markNotificationUnread(userId, notificationId) {
+  const normalizedID = notificationId.trim();
+  if (!normalizedID) {
+    return { kind: "not_found", notifications: await listNotificationsForUser(userId) };
+  }
+  const result = await updateNotificationRecords((notifications2) => {
+    let found = false;
+    const next = notifications2.map((notification) => {
+      if (notification.recipientUserId !== userId || notification.id !== normalizedID) return notification;
+      found = true;
+      if (!notification.readAt) return notification;
+      const { readAt: _readAt, ...unreadNotification } = notification;
+      return unreadNotification;
+    });
+    return {
+      next,
+      result: { found }
+    };
+  });
+  const notifications = await listNotificationsForUser(userId);
+  if (result.found) publishNotificationUpdates([userId]);
+  return result.found ? { kind: "updated", notifications } : { kind: "not_found", notifications };
+}
+async function markAllNotificationsRead(userId, now = /* @__PURE__ */ new Date()) {
+  const readAt = now.toISOString();
+  await updateNotificationRecords((notifications) => ({
+    next: notifications.map((notification) => notification.recipientUserId === userId && !notification.readAt ? { ...notification, readAt } : notification),
+    result: void 0
+  }));
+  publishNotificationUpdates([userId]);
+  return await listNotificationsForUser(userId);
+}
+async function markIssueNotificationsRead(userId, issueId, now = /* @__PURE__ */ new Date()) {
+  const normalizedIssueId = issueId.trim();
+  if (!normalizedIssueId) return await listNotificationsForUser(userId);
+  const readAt = now.toISOString();
+  const changed = await updateNotificationRecords((notifications) => {
+    let mutated = false;
+    const next = notifications.map((notification) => {
+      if (notification.recipientUserId !== userId || notification.issueId !== normalizedIssueId || notification.readAt) return notification;
+      mutated = true;
+      return { ...notification, readAt };
+    });
+    return { next, result: mutated };
+  });
+  if (changed) publishNotificationUpdates([userId]);
+  return await listNotificationsForUser(userId);
+}
+async function issueRecipientIds(issue, actorUserId) {
+  const ids = /* @__PURE__ */ new Set();
+  const reporterId = issue.creatorUserId ?? (await resolveUserByDisplayName(issue.creator, accountScopeForIssue(issue)))?.id;
+  if (reporterId) ids.add(reporterId);
+  for (const assignee of issueAssignees(issue)) {
+    const assigneeId = assignee.userId ?? (await resolveUserByDisplayName(assignee.name, accountScopeForIssue(issue)))?.id;
+    if (assigneeId) ids.add(assigneeId);
+  }
+  if (actorUserId) ids.delete(actorUserId);
+  const allowedIds = new Set((await listUsersForAdmin()).filter((user) => user.isActive && accountScopeCanViewVendor(user.accountScope, issue.creatorVendorId)).map((user) => user.id));
+  return [...ids].filter((id) => allowedIds.has(id));
+}
+function accountScopeForIssue(issue) {
+  const vendorId = issue.creatorVendorId ?? "hyperaccel";
+  return vendorId === "hyperaccel" ? "hyperaccel" : `vendor:${vendorId}`;
+}
+function issueAssignees(issue) {
+  const merged = [...issue.assignees ?? [], ...issue.assignee ? [issue.assignee] : []];
+  const byName = /* @__PURE__ */ new Map();
+  for (const assignee of merged) {
+    if (assignee.name.trim()) byName.set(assignee.name.trim().toLowerCase(), assignee);
+  }
+  return [...byName.values()];
+}
+function notificationsForUser(notifications, userId) {
+  return notifications.map((notification, index) => ({ notification, index })).filter((item) => item.notification.recipientUserId === userId).toSorted((left, right) => new Date(right.notification.createdAt).getTime() - new Date(left.notification.createdAt).getTime() || right.index - left.index).map((item) => item.notification);
+}
+function notificationInput(recipientUserId, issue, eventType, details) {
+  return {
+    recipientUserId,
+    issueId: issue.id,
+    eventId: details.eventId,
+    eventType,
+    title: details.title,
+    body: details.body,
+    linkUrl: `/issues/${issue.id}`
+  };
+}
+export {
+  clearNotificationStoreError,
+  compactNotificationRecords as compactNotificationStore,
+  createAdminTestNotification,
+  createIssueChangeNotifications,
+  createIssueCreatedNotifications,
+  createIssueDeletedNotifications,
+  createNotifications,
+  createSiteAnnouncementNotifications,
+  listNotificationsForUser,
+  markAllNotificationsRead,
+  markIssueNotificationsRead,
+  markNotificationRead,
+  markNotificationUnread,
+  notificationStoreStatus,
+  unreadNotificationCount
+};