@camox/api-contract 0.42.0 → 0.44.0

package/dist/index.js

@@ -0,0 +1,102 @@
+// src/icons.ts
+import { getIconData, iconToSVG } from "@iconify/utils";
+var ICON_CATALOG_VERSION = "2.2.532";
+var collections = /* @__PURE__ */ new Map();
+async function loadIconCollection(prefix) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(prefix)) throw new Error("Invalid icon collection");
+  const existing = collections.get(prefix);
+  if (existing) return existing;
+  const pending = (async () => {
+    const response = await fetch(
+      `https://unpkg.com/@iconify/json@${ICON_CATALOG_VERSION}/json/${prefix}.json`,
+      { signal: AbortSignal.timeout(3e4) }
+    );
+    if (!response.ok) throw new Error(`Unable to load icon collection ${prefix}`);
+    const data = await response.json();
+    if (data.prefix !== prefix || !data.icons || !data.info?.license)
+      throw new Error("Invalid icon catalog or missing license");
+    return data;
+  })();
+  collections.set(prefix, pending);
+  if (collections.size > 8) collections.delete(collections.keys().next().value);
+  try {
+    return await pending;
+  } catch (error) {
+    collections.delete(prefix);
+    throw error;
+  }
+}
+function iconCollectionIds(data) {
+  return [...Object.keys(data.icons), ...Object.keys(data.aliases ?? {})].filter((name) => getIconData(data, name) !== null).sort().map((name) => `${data.prefix}:${name}`);
+}
+function resolveIconSvg(data, id) {
+  const [prefix, name, extra] = id.split(":");
+  if (prefix !== data.prefix || !name || extra !== void 0) throw new Error("Invalid icon ID");
+  const icon = getIconData(data, name);
+  if (!icon) throw new Error(`Unknown icon: ${id}`);
+  const svg = iconToSVG(icon);
+  return {
+    body: svg.body,
+    attributes: svg.attributes,
+    attribution: data.info ? {
+      collection: data.info.name,
+      author: data.info.author.name,
+      license: data.info.license.title,
+      url: data.info.license.url
+    } : void 0
+  };
+}
+function scopeIconSvgIds(body, prefix) {
+  const ids = [...body.matchAll(/\sid="([^\s"]+)"/g)].map((match) => match[1]);
+  if (!ids.length) return body;
+  const pattern = ids.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return body.replace(
+    new RegExp(`([#;"])(${pattern})([")]|\\.[a-z])`, "g"),
+    (_match, before, id, after) => `${before}${prefix}${id}${after}`
+  );
+}
+function validateIconValue(value, schema) {
+  if (schema.fieldType !== "Icon") return;
+  if (typeof value !== "string" || !Array.isArray(schema.enum) || !schema.enum.includes(value)) {
+    throw new Error(`Invalid icon ID: ${String(value)}`);
+  }
+}
+
+// src/comments.ts
+import { z } from "zod";
+var COMMENT_MESSAGE_MAX_LENGTH = 1e4;
+var objectId = z.number().int().positive();
+var fieldName = z.string().min(1).max(200);
+var commentTargetSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("page") }),
+  z.strictObject({ kind: z.literal("block"), blockId: objectId }),
+  z.strictObject({ kind: z.literal("item"), blockId: objectId, itemId: objectId }),
+  z.strictObject({ kind: z.literal("block-field"), blockId: objectId, fieldName }),
+  z.strictObject({
+    kind: z.literal("item-field"),
+    blockId: objectId,
+    itemId: objectId,
+    fieldName
+  })
+]);
+var commentSchema = z.object({
+  id: z.uuid(),
+  pageId: objectId,
+  environmentId: objectId,
+  message: z.string(),
+  resolved: z.boolean(),
+  target: commentTargetSchema.nullable(),
+  author: z.object({ name: z.string(), image: z.string().nullable() }),
+  createdAt: z.number()
+});
+export {
+  COMMENT_MESSAGE_MAX_LENGTH,
+  ICON_CATALOG_VERSION,
+  commentSchema,
+  commentTargetSchema,
+  iconCollectionIds,
+  loadIconCollection,
+  resolveIconSvg,
+  scopeIconSvgIds,
+  validateIconValue
+};

package/dist/query-keys.d.ts

@@ -18,6 +18,10 @@ export type QueryKey = [first: "camox", ...rest: Array<string | number>];
  */
 export type ReadSource = "draft" | "live";
 export declare const queryKeys: {
+    comments: {
+        all: ["camox", string];
+        list: (pageId: number) => ["camox", string, string, number];
+    };
     pages: {
         list: ["camox", string, string];
         getByPath: (path: string, source?: ReadSource) => ["camox", string, string, string] | ["camox", string, string, string, ReadSource];

package/dist/query-keys.js

@@ -1,4 +1,8 @@
 export const queryKeys = {
+    comments: {
+        all: ["camox", "comments"],
+        list: (pageId) => ["camox", "comments", "list", pageId],
+    },
     pages: {
         list: ["camox", "pages", "list"],
         getByPath: (path, source) => source

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/api-contract",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "license": "MIT",
   "files": [
     "src",
@@ -17,6 +17,11 @@
       "default": "./dist/query-keys.js"
     }
   },
+  "dependencies": {
+    "@iconify/types": "^2.0.0",
+    "@iconify/utils": "^3.1.7",
+    "zod": "^4.4.3"
+  },
   "devDependencies": {
     "dts-bundle-generator": "^9.5.1",
     "esbuild": "^0.25.12"

package/src/comments.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+
+export const COMMENT_MESSAGE_MAX_LENGTH = 10_000;
+
+const objectId = z.number().int().positive();
+const fieldName = z.string().min(1).max(200);
+
+export const commentTargetSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("page") }),
+  z.strictObject({ kind: z.literal("block"), blockId: objectId }),
+  z.strictObject({ kind: z.literal("item"), blockId: objectId, itemId: objectId }),
+  z.strictObject({ kind: z.literal("block-field"), blockId: objectId, fieldName }),
+  z.strictObject({
+    kind: z.literal("item-field"),
+    blockId: objectId,
+    itemId: objectId,
+    fieldName,
+  }),
+]);
+
+export const commentSchema = z.object({
+  id: z.uuid(),
+  pageId: objectId,
+  environmentId: objectId,
+  message: z.string(),
+  resolved: z.boolean(),
+  target: commentTargetSchema.nullable(),
+  author: z.object({ name: z.string(), image: z.string().nullable() }),
+  createdAt: z.number(),
+});
+
+export type CommentTarget = z.infer<typeof commentTargetSchema>;
+export type Comment = z.infer<typeof commentSchema>;

package/src/icons.ts

@@ -0,0 +1,84 @@
+import type { IconifyJSON } from "@iconify/types";
+import { getIconData, iconToSVG } from "@iconify/utils";
+
+// One immutable snapshot for declarations, schemas, picker and SVG resolution.
+export const ICON_CATALOG_VERSION = "2.2.532";
+export type IconSvgData = {
+  body: string;
+  attributes: Record<string, string>;
+  attribution?: { collection: string; author: string; license: string; url?: string };
+};
+const collections = new Map<string, Promise<IconifyJSON>>();
+
+export async function loadIconCollection(prefix: string): Promise<IconifyJSON> {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(prefix)) throw new Error("Invalid icon collection");
+  const existing = collections.get(prefix);
+  if (existing) return existing;
+  const pending = (async () => {
+    const response = await fetch(
+      `https://unpkg.com/@iconify/json@${ICON_CATALOG_VERSION}/json/${prefix}.json`,
+      { signal: AbortSignal.timeout(30_000) },
+    );
+    if (!response.ok) throw new Error(`Unable to load icon collection ${prefix}`);
+    const data = (await response.json()) as IconifyJSON;
+    if (data.prefix !== prefix || !data.icons || !data.info?.license)
+      throw new Error("Invalid icon catalog or missing license");
+    return data;
+  })();
+  collections.set(prefix, pending);
+  // Bound worker memory; failed fetches must be retryable.
+  if (collections.size > 8) collections.delete(collections.keys().next().value!);
+  try {
+    return await pending;
+  } catch (error) {
+    collections.delete(prefix);
+    throw error;
+  }
+}
+
+export function iconCollectionIds(data: IconifyJSON): string[] {
+  return [...Object.keys(data.icons), ...Object.keys(data.aliases ?? {})]
+    .filter((name) => getIconData(data, name) !== null)
+    .sort()
+    .map((name) => `${data.prefix}:${name}`);
+}
+
+export function resolveIconSvg(data: IconifyJSON, id: string): IconSvgData {
+  const [prefix, name, extra] = id.split(":");
+  if (prefix !== data.prefix || !name || extra !== undefined) throw new Error("Invalid icon ID");
+  const icon = getIconData(data, name);
+  if (!icon) throw new Error(`Unknown icon: ${id}`);
+  const svg = iconToSVG(icon);
+  return {
+    body: svg.body,
+    attributes: svg.attributes,
+    attribution: data.info
+      ? {
+          collection: data.info.name,
+          author: data.info.author.name,
+          license: data.info.license.title,
+          url: data.info.license.url,
+        }
+      : undefined,
+  };
+}
+
+export function scopeIconSvgIds(body: string, prefix: string): string {
+  const ids = [...body.matchAll(/\sid="([^\s"]+)"/g)].map((match) => match[1]!);
+  if (!ids.length) return body;
+  const pattern = ids.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return body.replace(
+    new RegExp(`([#;"])(${pattern})([")]|\\.[a-z])`, "g"),
+    (_match, before: string, id: string, after: string) => `${before}${prefix}${id}${after}`,
+  );
+}
+
+export function validateIconValue(
+  value: unknown,
+  schema: { fieldType?: string; enum?: unknown },
+): void {
+  if (schema.fieldType !== "Icon") return;
+  if (typeof value !== "string" || !Array.isArray(schema.enum) || !schema.enum.includes(value)) {
+    throw new Error(`Invalid icon ID: ${String(value)}`);
+  }
+}

package/src/index.ts

@@ -1 +1,3 @@
+export * from "./icons.ts";
+export * from "./comments.ts";
 export type { Router } from "../../../apps/api/src/router";

package/src/query-keys.ts

@@ -21,6 +21,10 @@ type QueryKeyGroup = Record<string, QueryKey | ((...args: any[]) => QueryKey)>;
 export type ReadSource = "draft" | "live";
 
 export const queryKeys = {
+  comments: {
+    all: ["camox", "comments"],
+    list: (pageId: number) => ["camox", "comments", "list", pageId],
+  },
   pages: {
     list: ["camox", "pages", "list"],
     getByPath: (path: string, source?: ReadSource) =>