@neta-art/cohub 12.1.1 → 12.3.0

package/dist/board/stage/texture-pool.d.ts

@@ -7,6 +7,15 @@ type BoardImageTexturePool = {
 /** A CDN variant that fails to process falls back to the media it came from. */
 declare function loadBoardImageTexture(url: string): Promise<Texture>;
 declare function unloadBoardImageTexture(url: string, texture: Texture | null): Promise<void>;
+/**
+ * Decode an image no larger than `edge` along its long side (short side with
+ * `cover`), for sources without CDN variants. The texture is unshared; destroy
+ * it to release it.
+ */
+declare function loadFittedImageTexture(url: string, edge: number, cover?: boolean): Promise<Texture>;
+/** A smaller unshared copy of a decoded texture, or null when it cannot be read back. */
+declare function shrinkBoardTexture(texture: Texture, edge: number): Promise<Texture | null>;
+declare function readTextureTone(texture: Texture): Promise<number | null>;
 /**
  * Share image textures by resolved URL without sharing Board ownership.
  *
@@ -21,4 +30,4 @@ declare function createBoardImageTexturePool(options?: {
 }): BoardImageTexturePool;
 declare const boardImageTexturePool: BoardImageTexturePool;
 //#endregion
-export { BoardImageTexturePool, boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture };
+export { BoardImageTexturePool, boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, readTextureTone, shrinkBoardTexture, unloadBoardImageTexture };

package/dist/board/stage/texture-pool.js

@@ -1,6 +1,6 @@
 import { variantSource } from "../../media.js";
 import { loadVideoThumbnailTexture } from "../render/video-thumbnail.js";
-import { Assets, Texture } from "pixi.js";
+import { Assets, DOMAdapter, Texture } from "pixi.js";
 //#region src/board/stage/texture-pool.ts
 /** Load an image in the page's CORS context when Pixi's worker path fails. */
 function loadImageElementTexture(url) {
@@ -62,6 +62,76 @@ async function unloadBoardImageTexture(url, texture) {
 	await Assets.unload(url).catch(() => {});
 	if (!texture?.destroyed) texture?.destroy(true);
 }
+function fit(width, height, edge, cover = false) {
+	const scale = edge / (cover ? Math.min(width, height) : Math.max(width, height));
+	return scale < 1 ? {
+		resizeWidth: Math.max(1, Math.round(width * scale)),
+		resizeHeight: Math.max(1, Math.round(height * scale))
+	} : null;
+}
+/**
+* Decode an image no larger than `edge` along its long side (short side with
+* `cover`), for sources without CDN variants. The texture is unshared; destroy
+* it to release it.
+*/
+async function loadFittedImageTexture(url, edge, cover = false) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	const image = await createImageBitmap(await response.blob());
+	const size = fit(image.width, image.height, edge, cover);
+	if (!size) return Texture.from(image, true);
+	try {
+		return Texture.from(await createImageBitmap(image, {
+			...size,
+			resizeQuality: "high"
+		}), true);
+	} finally {
+		image.close();
+	}
+}
+/** A smaller unshared copy of a decoded texture, or null when it cannot be read back. */
+async function shrinkBoardTexture(texture, edge) {
+	const resource = texture.source.resource;
+	const size = fit(texture.width, texture.height, edge);
+	if (!resource || !size || typeof createImageBitmap !== "function") return null;
+	return Texture.from(await createImageBitmap(resource, {
+		...size,
+		resizeQuality: "medium"
+	}), true);
+}
+const TONE_SAMPLE = 8;
+let toneContext;
+async function readTextureTone(texture) {
+	const resource = texture.source.resource;
+	if (!resource || texture.destroyed) return null;
+	const bitmap = await createImageBitmap(resource, {
+		resizeWidth: TONE_SAMPLE,
+		resizeHeight: TONE_SAMPLE,
+		resizeQuality: "medium"
+	});
+	try {
+		toneContext ??= DOMAdapter.get().createCanvas(TONE_SAMPLE, TONE_SAMPLE).getContext("2d", { willReadFrequently: true });
+		if (!toneContext) return null;
+		toneContext.clearRect(0, 0, TONE_SAMPLE, TONE_SAMPLE);
+		toneContext.drawImage(bitmap, 0, 0);
+		const { data } = toneContext.getImageData(0, 0, TONE_SAMPLE, TONE_SAMPLE);
+		let red = 0;
+		let green = 0;
+		let blue = 0;
+		let weight = 0;
+		for (let index = 0; index < data.length; index += 4) {
+			const alpha = data[index + 3];
+			red += data[index] * alpha;
+			green += data[index + 1] * alpha;
+			blue += data[index + 2] * alpha;
+			weight += alpha;
+		}
+		if (weight === 0) return null;
+		return Math.round(red / weight) << 16 | Math.round(green / weight) << 8 | Math.round(blue / weight);
+	} finally {
+		bitmap.close();
+	}
+}
 /**
 * Share image textures by resolved URL without sharing Board ownership.
 *
@@ -150,4 +220,4 @@ function createBoardImageTexturePool(options) {
 }
 const boardImageTexturePool = createBoardImageTexturePool();
 //#endregion
-export { boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture };
+export { boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, readTextureTone, shrinkBoardTexture, unloadBoardImageTexture };

package/dist/chunks/environment.d.ts

@@ -1358,6 +1358,12 @@ declare const BoardExtensionItemSchema: z.ZodObject<{
   }, z.core.$strict>>;
   type: z.ZodString;
   props: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  preview: z.ZodOptional<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    excerpt: z.ZodOptional<z.ZodString>;
+    cover: z.ZodOptional<z.ZodString>;
+    src: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
 }, z.core.$strict>;
 declare const BOARD_ITEM_SCHEMAS: {
   readonly frame: z.ZodObject<{

package/dist/chunks/http.d.ts

@@ -1251,6 +1251,7 @@ type BoardRemote = {
         playback: BoardPlaybackSnapshot | null;
       };
     }) => void;
+    resync?: () => void;
   }): () => void;
 };
 //#endregion
@@ -1264,6 +1265,7 @@ type BoardSubscriptionHandlers = {
   awareness?: (event: BoardAwarenessUpdatedEvent) => void;
   playback?: (event: BoardPlaybackChangedEvent) => void;
   event?: (event: BoardChangedEvent | BoardAwarenessUpdatedEvent | BoardPlaybackChangedEvent) => void;
+  resync?: () => void;
 };
 type BoardClientOptions = {
   http: HttpTransport;
@@ -1316,12 +1318,18 @@ declare class BoardClient implements BoardRemote {
   on(type: "awareness", handler: (event: BoardAwarenessUpdatedEvent) => void): () => void;
   on(type: "playback", handler: (event: BoardPlaybackChangedEvent) => void): () => void;
 }
+type BoardFileReader = {
+  read(path: string, customFetch?: Fetch): Promise<SpaceFsFileResponse | SpaceFsPreparingFile>;
+};
 declare class SpaceBoardsApi {
   private readonly http;
   private readonly spaceId;
   private readonly websocket;
-  constructor(http: HttpTransport, spaceId: string, websocket: WebsocketClient | null);
+  private readonly files;
+  constructor(http: HttpTransport, spaceId: string, websocket: WebsocketClient | null, files: BoardFileReader);
   byId(boardId: string): BoardClient;
+  open(target: string, customFetch?: Fetch): Promise<BoardClient>;
+  resolveId(path: string, customFetch?: Fetch): Promise<string>;
   /** Create a `.board` file and its Board, optionally with an initial document. */
   create(input: BoardCreateInput): Promise<BoardReadResult>;
 }