@xnetjs/data 0.0.2 → 0.1.0

package/dist/chunk-PMUQACPY.js

@@ -0,0 +1,33 @@
+// src/schema/extension.ts
+var EXT_PREFIX = "ext:";
+var AUTHORITY_PATTERN = /^[^/\s]+$/;
+var FIELD_PATTERN = /^[^/\s]+$/;
+function extKey(authority, field) {
+  if (!AUTHORITY_PATTERN.test(authority)) {
+    throw new Error(`Invalid extension authority: ${JSON.stringify(authority)}`);
+  }
+  if (!FIELD_PATTERN.test(field)) {
+    throw new Error(`Invalid extension field name: ${JSON.stringify(field)}`);
+  }
+  return `${EXT_PREFIX}${authority}/${field}`;
+}
+function isExtKey(key) {
+  return parseExtKey(key) !== null;
+}
+function parseExtKey(key) {
+  if (!key.startsWith(EXT_PREFIX)) return null;
+  const rest = key.slice(EXT_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) return null;
+  const authority = rest.slice(0, slash);
+  const field = rest.slice(slash + 1);
+  if (!AUTHORITY_PATTERN.test(authority) || !FIELD_PATTERN.test(field)) return null;
+  return { authority, field };
+}
+
+export {
+  EXT_PREFIX,
+  extKey,
+  isExtKey,
+  parseExtKey
+};

package/dist/chunk-PNESGUH5.js

@@ -0,0 +1,63 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-OCMSAKWV.js";
+import {
+  created,
+  createdBy,
+  date,
+  defineSchema,
+  json,
+  relation,
+  select,
+  text,
+  url
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/external-item.ts
+var EXTERNAL_ITEM_SCHEMA_IRI = "xnet://xnet.fyi/ExternalItem@1.0.0";
+var EXTERNAL_ITEM_SOURCES = [
+  { id: "github", name: "GitHub" },
+  { id: "notion", name: "Notion" },
+  { id: "airtable", name: "Airtable" },
+  { id: "linear", name: "Linear" },
+  { id: "stripe", name: "Stripe" },
+  { id: "sentry", name: "Sentry" },
+  { id: "pagerduty", name: "PagerDuty" },
+  { id: "other", name: "Other" }
+];
+var ExternalItemSchema = defineSchema({
+  name: "ExternalItem",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Originating service. */
+    source: select({ options: EXTERNAL_ITEM_SOURCES, required: true }),
+    /** Service-specific object kind, e.g. `issue`, `pull_request`, `page`, `record`. */
+    kind: text({ required: true, maxLength: 100 }),
+    /** Stable id in the source system, used to de-duplicate re-syncs. */
+    externalId: text({ required: true, maxLength: 500 }),
+    /** Display title. */
+    title: text({ required: true, maxLength: 1e3 }),
+    /** Canonical link back to the source object. */
+    url: url({}),
+    /** Body / description text. */
+    body: text({}),
+    /** Free-form status string from the source (e.g. `open`, `closed`, `done`). */
+    status: text({ maxLength: 100 }),
+    /** When the source object was last updated (Unix ms). */
+    updatedAt: date({ includeTime: true }),
+    /** The original payload, preserved for fidelity. */
+    raw: json({}),
+    /** The home Space — drives the authorization cascade. */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" }),
+    createdAt: created(),
+    createdBy: createdBy()
+  },
+  document: void 0,
+  authorization: spaceCascadeAuthorization()
+});
+
+export {
+  EXTERNAL_ITEM_SCHEMA_IRI,
+  EXTERNAL_ITEM_SOURCES,
+  ExternalItemSchema
+};

package/dist/chunk-Q3IEGH4B.js

@@ -0,0 +1,51 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-OCMSAKWV.js";
+import {
+  checkbox,
+  created,
+  createdBy,
+  date,
+  defineSchema,
+  file,
+  json,
+  relation,
+  text
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/chat-message.ts
+var ChatMessageSchema = defineSchema({
+  name: "ChatMessage",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** The channel this message belongs to */
+    channel: relation({ target: "xnet://xnet.fyi/Channel@1.0.0", required: true }),
+    /** Message body in GitHub-flavored markdown */
+    content: text({ required: true, maxLength: 1e4 }),
+    /** Thread root message (flat threading, like Comment.inReplyTo) */
+    inReplyTo: relation({ target: "xnet://xnet.fyi/ChatMessage@1.0.0" }),
+    /** Optional file attachments */
+    attachments: file({ multiple: true }),
+    /** Structured mentions ({ dids, room? }) — populated by the composer */
+    mentions: json({}),
+    /** Whether the message has been edited */
+    edited: checkbox({ default: false }),
+    /** When the message was last edited */
+    editedAt: date({}),
+    /** Soft tombstone: content removed, message shell kept for thread shape */
+    redacted: checkbox({ default: false }),
+    /** Workspace-wide labels from inline #hashtag pills (exploration 0169) */
+    tags: relation({ target: "xnet://xnet.fyi/Tag@1.0.0", multiple: true }),
+    /** Node ids from the composer's [[ link picks (exploration 0170) */
+    links: relation({ multiple: true }),
+    createdAt: created(),
+    createdBy: createdBy()
+  },
+  document: void 0,
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization("channel")
+});
+
+export {
+  ChatMessageSchema
+};

package/dist/chunk-QJW5LDP4.js

@@ -0,0 +1,52 @@
+import {
+  spaceCascadeAuthorization
+} from "./chunk-OCMSAKWV.js";
+import {
+  defineSchema,
+  json,
+  relation,
+  select,
+  text
+} from "./chunk-EBNMV2VO.js";
+
+// src/schema/schemas/dashboard.ts
+var DashboardSchema = defineSchema({
+  name: "Dashboard",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Dashboard title */
+    title: text({ required: true, maxLength: 500 }),
+    /** Emoji or icon URL */
+    icon: text({}),
+    /** Dashboard variable scope (time range, custom vars) — whole-value LWW */
+    variables: json({}),
+    /** Widget instances placed on this dashboard — whole-list LWW */
+    widgets: json({}),
+    /** Per-breakpoint {x, y, w, h} layout maps — whole-value LWW */
+    layouts: json({}),
+    /** Canonical home; empty = Unfiled (exploration 0169) */
+    folder: relation({ target: "xnet://xnet.fyi/Folder@1.0.0" }),
+    /** Order among folder siblings — fractional index */
+    sortKey: text({ maxLength: 500 }),
+    /** Workspace-wide labels, referenced by id (exploration 0169) */
+    tags: relation({ target: "xnet://xnet.fyi/Tag@1.0.0", multiple: true }),
+    /** Canonical SECURITY home; empty = personal/private (exploration 0179) */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" }),
+    /** Per-node visibility; `inherit` defers to the Space (exploration 0179) */
+    visibility: select({
+      options: [
+        { id: "inherit", name: "Inherit", color: "gray" },
+        { id: "private", name: "Private", color: "gray" },
+        { id: "unlisted", name: "Unlisted", color: "yellow" },
+        { id: "public", name: "Public", color: "green" }
+      ],
+      default: "inherit"
+    })
+  },
+  // Inherits access from its home Space (exploration 0181/0192).
+  authorization: spaceCascadeAuthorization()
+});
+
+export {
+  DashboardSchema
+};

package/dist/chunk-QWFTRZQT.js

@@ -0,0 +1,142 @@
+// src/database/fractional-index.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var BASE = ALPHABET.length;
+var START_KEY = "a0";
+var MIDPOINT_CHAR = ALPHABET[Math.floor(BASE / 2)];
+function generateSortKey(before, after) {
+  if (!before && !after) {
+    return START_KEY;
+  }
+  if (before && !after) {
+    return incrementKey(before);
+  }
+  if (!before && after) {
+    return prependKey(after);
+  }
+  return midpointKey(before, after);
+}
+function generateSortKeyWithJitter(before, after) {
+  const base = generateSortKey(before, after);
+  const jitter = ALPHABET[randomInt(BASE)] + ALPHABET[randomInt(BASE)];
+  return base + jitter;
+}
+function incrementKey(key) {
+  const chars = key.split("");
+  let i = chars.length - 1;
+  while (i >= 0) {
+    const idx = ALPHABET.indexOf(chars[i]);
+    if (idx < BASE - 1) {
+      chars[i] = ALPHABET[idx + 1];
+      return chars.join("");
+    }
+    chars[i] = ALPHABET[0];
+    i--;
+  }
+  return key + ALPHABET[0];
+}
+function prependKey(key) {
+  const chars = key.split("");
+  for (let i = 0; i < chars.length; i++) {
+    const idx = ALPHABET.indexOf(chars[i]);
+    if (idx > 0) {
+      chars[i] = ALPHABET[idx - 1];
+      return chars.slice(0, i + 1).join("") + ALPHABET[BASE - 1];
+    }
+  }
+  return ALPHABET[0] + key.slice(1) + MIDPOINT_CHAR;
+}
+function midpointKey(before, after) {
+  if (before >= after) {
+    throw new Error(`Invalid key order: "${before}" >= "${after}"`);
+  }
+  const maxLen = Math.max(before.length, after.length) + 1;
+  const paddedBefore = before.padEnd(maxLen, ALPHABET[0]);
+  const paddedAfter = after.padEnd(maxLen, ALPHABET[0]);
+  for (let i = 0; i < maxLen; i++) {
+    const beforeIdx = ALPHABET.indexOf(paddedBefore[i]);
+    const afterIdx = ALPHABET.indexOf(paddedAfter[i]);
+    if (beforeIdx === afterIdx) {
+      continue;
+    }
+    if (afterIdx - beforeIdx > 1) {
+      const midIdx = Math.floor((beforeIdx + afterIdx) / 2);
+      return paddedBefore.slice(0, i) + ALPHABET[midIdx];
+    }
+    for (let j = i + 1; j < maxLen; j++) {
+      const bIdx = ALPHABET.indexOf(paddedBefore[j]);
+      const aIdx = ALPHABET.indexOf(paddedAfter[j]);
+      if (aIdx > bIdx + 1) {
+        const midIdx = Math.floor((bIdx + aIdx) / 2);
+        return paddedBefore.slice(0, j) + ALPHABET[midIdx];
+      } else if (aIdx > bIdx) {
+        continue;
+      } else {
+        const midIdx = Math.floor((bIdx + BASE) / 2);
+        return paddedBefore.slice(0, j) + ALPHABET[midIdx];
+      }
+    }
+    return before + MIDPOINT_CHAR;
+  }
+  for (let i = before.length; i < after.length; i++) {
+    const afterIdx = ALPHABET.indexOf(after[i]);
+    if (afterIdx > 0) {
+      const midIdx = Math.floor(afterIdx / 2);
+      return before + ALPHABET[0].repeat(i - before.length) + ALPHABET[midIdx];
+    }
+  }
+  return before + MIDPOINT_CHAR;
+}
+function isValidSortKey(key) {
+  if (!key || key.length === 0) return false;
+  return key.split("").every((c) => ALPHABET.includes(c));
+}
+function compareSortKeys(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function rebalanceSortKeys(rowIds) {
+  const result = /* @__PURE__ */ new Map();
+  if (rowIds.length === 0) {
+    return result;
+  }
+  for (let i = 0; i < rowIds.length; i++) {
+    const key = indexToKey(i, rowIds.length);
+    result.set(rowIds[i], key);
+  }
+  return result;
+}
+function indexToKey(index, total) {
+  const charCount = total <= BASE * BASE ? 2 : 3;
+  const range = Math.pow(BASE, charCount);
+  const step = Math.floor(range / (total + 1));
+  const value = step * (index + 1);
+  return valueToKey(value, charCount);
+}
+function valueToKey(value, length) {
+  let result = "";
+  let remaining = value;
+  for (let i = 0; i < length; i++) {
+    const idx = remaining % BASE;
+    result = ALPHABET[idx] + result;
+    remaining = Math.floor(remaining / BASE);
+  }
+  return result;
+}
+function randomInt(max) {
+  return Math.floor(Math.random() * max);
+}
+var MAX_KEY_LENGTH = 10;
+function needsRebalancing(sortKeys) {
+  return sortKeys.some((key) => key.length > MAX_KEY_LENGTH);
+}
+
+export {
+  generateSortKey,
+  generateSortKeyWithJitter,
+  isValidSortKey,
+  compareSortKeys,
+  rebalanceSortKeys,
+  MAX_KEY_LENGTH,
+  needsRebalancing
+};