@streamplace/components 0.0.1 → 0.7.0

package/src/index.tsx

@@ -0,0 +1,27 @@
+// barrel file :)
+export * from "./livestream-provider";
+export * from "./livestream-store";
+export * from "./player-store";
+export * from "./streamplace-provider";
+export * from "./streamplace-store";
+
+export {
+  PlayerProvider,
+  withPlayerProvider,
+} from "./player-store/player-provider";
+export { usePlayerContext } from "./player-store/player-store";
+
+export { Player, PlayerUI } from "./components/mobile-player/player";
+export { PlayerProps } from "./components/mobile-player/props";
+
+export * as ui from "./components/ui";
+
+export * from "./components/ui";
+
+export * as theme from "./lib/theme";
+export * as atoms from "./lib/theme/atoms";
+
+export * from "./hooks";
+
+export * from "./components/chat/chat";
+export * from "./components/chat/chat-box";

package/src/lib/facet.ts

@@ -0,0 +1,131 @@
+// Taken from ATcute's richtext-segmenter
+// https://github.com/mary-ext/atcute/blob/trunk/packages/bluesky/richtext-segmenter/lib/index.ts
+// repoed b/c we need to import types from @atproto/api not @atcute/bsky
+import { Main } from "@atproto/api/dist/client/types/app/bsky/richtext/facet";
+
+type UnwrapArray<T> = T extends (infer V)[] ? V : never;
+
+export type Facet = Main;
+export type FacetFeature = UnwrapArray<Facet["features"]>;
+
+export interface RichtextSegment {
+  text: string;
+  features: FacetFeature[] | undefined;
+}
+
+const segment = (
+  text: string,
+  features: FacetFeature[] | undefined,
+): RichtextSegment => {
+  return { text, features: text.length > 0 ? features : undefined };
+};
+
+export const segmentize = (
+  text: string,
+  facets: Facet[] | undefined,
+): RichtextSegment[] => {
+  if (facets === undefined || facets.length === 0) {
+    return [segment(text, undefined)];
+  }
+
+  const segments: RichtextSegment[] = [];
+  const utf16Length = text.length;
+  let utf16Cursor = 0;
+  let utf8Cursor = 0;
+
+  const advanceCursor = (startUtf16: number, endUtf8: number): number => {
+    let curs = startUtf16;
+
+    // Fast-path for entirely ASCII text
+    const isLikelyAsciiText = text.charCodeAt(curs) < 0x80;
+    if (isLikelyAsciiText) {
+      curs += 1;
+      utf8Cursor += 1;
+
+      // SIMD-like batch processing
+      while (utf8Cursor + 8 <= endUtf8 && curs + 8 <= utf16Length) {
+        const char1 = text.charCodeAt(curs);
+        const char2 = text.charCodeAt(curs + 1);
+        const char3 = text.charCodeAt(curs + 2);
+        const char4 = text.charCodeAt(curs + 3);
+        const char5 = text.charCodeAt(curs + 4);
+        const char6 = text.charCodeAt(curs + 5);
+        const char7 = text.charCodeAt(curs + 6);
+        const char8 = text.charCodeAt(curs + 7);
+
+        if (
+          (char1 | char2 | char3 | char4 | char5 | char6 | char7 | char8) <
+          0x80
+        ) {
+          curs += 8;
+          utf8Cursor += 8;
+          continue;
+        }
+
+        break;
+      }
+    }
+
+    // Process remaining characters individually
+    while (utf8Cursor < endUtf8 && curs < utf16Length) {
+      const code = text.charCodeAt(curs);
+
+      if (code < 0x80) {
+        curs += 1;
+        utf8Cursor += 1;
+      } else if (code < 0x800) {
+        curs += 1;
+        utf8Cursor += 2;
+      } else if (code < 0xd800 || code > 0xdbff) {
+        curs += 1;
+        utf8Cursor += 3;
+      } else {
+        curs += 2;
+        utf8Cursor += 4;
+      }
+    }
+
+    return curs;
+  };
+
+  // Process facets
+  for (let idx = 0, len = facets.length; idx < len; idx++) {
+    const facet = facets[idx];
+
+    const { byteStart, byteEnd } = facet.index;
+    const features = facet.features;
+
+    if (byteStart > byteEnd || features.length === 0) {
+      continue;
+    }
+
+    if (utf8Cursor < byteStart) {
+      const nextUtf16Cursor = advanceCursor(utf16Cursor, byteStart);
+      if (nextUtf16Cursor > utf16Cursor) {
+        segments.push(
+          segment(text.slice(utf16Cursor, nextUtf16Cursor), undefined),
+        );
+      }
+
+      utf16Cursor = nextUtf16Cursor;
+    }
+
+    {
+      const nextUtf16Cursor = advanceCursor(utf16Cursor, byteEnd);
+      if (nextUtf16Cursor > utf16Cursor) {
+        segments.push(
+          segment(text.slice(utf16Cursor, nextUtf16Cursor), features),
+        );
+      }
+
+      utf16Cursor = nextUtf16Cursor;
+    }
+  }
+
+  // Handle remaining text
+  if (utf16Cursor < utf16Length) {
+    segments.push(segment(text.slice(utf16Cursor), undefined));
+  }
+
+  return segments;
+};