@boldvideo/bold-js 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @boldvideo/bold-js
 
+## 0.7.0
+
+### Minor Changes
+
+- Add `color_scheme` field to Portal type (BOLD-759)
+
+  Added optional `color_scheme` field to the Portal type to support theme configuration:
+
+  - `'toggle'`: Show theme toggle, allow user to switch between light/dark
+  - `'light'`: Force light mode, hide theme toggle
+  - `'dark'`: Force dark mode, hide theme toggle
+
+  This field is already returned by the API and consumed by the Next.js starter. The type definition now matches the API response.
+
+## 0.6.1
+
+### Patch Changes
+
+- Fix missing compiled dist files in published package by adding .npmignore
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/client.ts
+var import_axios = __toESM(require("axios"), 1);
+
+// src/lib/fetchers.ts
+function get(client, url) {
+  return __async(this, null, function* () {
+    try {
+      const res = yield client.get(url);
+      if (res.status !== 200) {
+        throw new Error(`Unexpected response status: ${res.status}`);
+      }
+      return res.data;
+    } catch (error) {
+      console.error(`Error fetching data from URL: ${url}`, error);
+      throw error;
+    }
+  });
+}
+function fetchSettings(client) {
+  return (videoLimit = 12) => __async(this, null, function* () {
+    try {
+      return yield get(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  });
+}
+function fetchVideos(client) {
+  return (videoLimit = 12) => __async(this, null, function* () {
+    try {
+      return yield get(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  });
+}
+function searchVideos(client) {
+  return (term) => __async(this, null, function* () {
+    try {
+      return yield get(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
+  });
+}
+function fetchVideo(client) {
+  return (id) => __async(this, null, function* () {
+    try {
+      return yield get(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
+  });
+}
+function fetchPlaylists(client) {
+  return () => __async(this, null, function* () {
+    try {
+      return yield get(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
+  });
+}
+function fetchPlaylist(client) {
+  return (id) => __async(this, null, function* () {
+    try {
+      return yield get(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
+  });
+}
+
+// src/util/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled)
+        return void 0;
+      if (wait)
+        return void 0;
+      const val = fn(...args);
+      wait = true;
+      timeout = window.setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout);
+    }
+  ];
+};
+
+// src/lib/tracking.ts
+function sendEvent(client, eventName, data, debug) {
+  const payload = {
+    n: eventName,
+    u: data.url,
+    usr: data.userId,
+    d: data.domain,
+    ua: data.userAgent,
+    w: data.deviceWidth,
+    vid: (data == null ? void 0 : data.videoId) || void 0,
+    vt: data.title,
+    vdur: (data == null ? void 0 : data.videoDuration) || void 0,
+    time: (data == null ? void 0 : data.currentTime) || void 0
+  };
+  if (debug)
+    console.log(`Bold SDK - Logging event '${eventName}'`, payload);
+  client.post("/event", payload);
+}
+var [throttledSendEvent] = throttle(sendEvent, 5e3);
+function trackEvent(client, userId, options) {
+  return (video, event) => {
+    var _a;
+    const eventDetails = __spreadProps(__spreadValues({}, basicInfos()), {
+      userId,
+      videoId: video.id,
+      title: video.title,
+      videoDuration: video.duration,
+      currentTime: ((_a = event.target) == null ? void 0 : _a.currentTime) || 0
+    });
+    if (event.type == "timeupdate" || event.type == "time-update") {
+      throttledSendEvent(
+        client,
+        getEventName(event),
+        eventDetails,
+        options.debug
+      );
+    } else {
+      sendEvent(client, getEventName(event), eventDetails, options.debug);
+    }
+  };
+}
+function trackPageView(client, userId, options) {
+  return (title) => {
+    const eventDetails = __spreadProps(__spreadValues({}, basicInfos()), {
+      userId,
+      title
+    });
+    sendEvent(client, "page_view", eventDetails, options.debug);
+  };
+}
+function getEventName(event) {
+  switch (event.type) {
+    case "pause":
+      return "video_pause";
+    case "play":
+      return "video_resume";
+    case "loadedmetadata":
+    case "loaded-metadata":
+      return "video_load";
+    case "time-update":
+    case "timeupdate":
+      return "video_progress";
+    default:
+      return "unknown_event";
+  }
+}
+function basicInfos() {
+  return {
+    url: location.href,
+    domain: location.hostname,
+    referrer: document.referrer || null,
+    deviceWidth: window.innerWidth,
+    userAgent: navigator.userAgent
+  };
+}
+
+// src/lib/client.ts
+function createClient(apiKey, options = { debug: false }) {
+  var _a;
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error("API key is missing or invalid");
+  }
+  const { debug } = options;
+  const apiClientOptions = {
+    baseURL: (_a = options.baseURL) != null ? _a : "https://app.boldvideo.io/api/v1/",
+    headers: {
+      Authorization: apiKey
+    }
+  };
+  let apiClient;
+  try {
+    apiClient = import_axios.default.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
+  const userId = [...Array(30)].map(() => Math.random().toString(36)[2]).join("");
+  return {
+    settings: fetchSettings(apiClient),
+    videos: {
+      list: fetchVideos(apiClient),
+      get: fetchVideo(apiClient),
+      search: searchVideos(apiClient)
+    },
+    playlists: {
+      list: fetchPlaylists(apiClient),
+      get: fetchPlaylist(apiClient)
+    },
+    trackEvent: trackEvent(apiClient, userId, { debug }),
+    trackPageView: trackPageView(apiClient, userId, { debug })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClient
+});

package/dist/index.d.ts

@@ -0,0 +1,197 @@
+type VideoAttachment = {
+    id: string;
+    title: string;
+    file_url: string;
+    file_size?: number;
+    file_type?: string;
+};
+type VideoDownloadUrls = {
+    mp4?: string;
+    audio?: string;
+    legacy_mp4?: string;
+};
+type VideoSubtitles = {
+    label: string;
+    url: string;
+    engine?: string;
+    language: string;
+};
+type VideoTranscript = {
+    text: string;
+    json: any;
+};
+type VideoMetadata = {
+    description: string;
+    title: string;
+    image: string | null;
+};
+type Video = {
+    captions: string;
+    captions_label: string;
+    captions_lang: string;
+    description: string | null;
+    duration: number;
+    id: string;
+    imported_from: string | null;
+    legacy_video_url: string | null;
+    playback_id: string;
+    published_at: string;
+    stream_url: string;
+    teaser: string | null;
+    thumbnail: string;
+    title: string;
+    type: string;
+    meta_data: VideoMetadata;
+    chapters?: string;
+    attachments?: VideoAttachment[];
+    cta?: any | null;
+    download_urls?: VideoDownloadUrls;
+    internal_id?: string;
+    playback_speed?: number;
+    subtitles?: VideoSubtitles;
+    tags?: string[];
+    transcript?: VideoTranscript;
+};
+type Playlist = {
+    description?: string;
+    id: string;
+    is_private: boolean;
+    title: string;
+    type: string;
+    videos: Video[];
+};
+type MenuItem = {
+    icon: string;
+    is_ext: boolean;
+    label: string;
+    url: string;
+};
+type PortalDisplay = {
+    show_chapters: boolean;
+    show_transcripts: boolean;
+};
+type AssistantConfig = {
+    headline: string;
+    subheadline: string;
+    suggestions: string[];
+};
+type PortalLayout = {
+    assistant_config: AssistantConfig | null;
+    show_playlists: boolean;
+    type: string;
+    videos_limit: number;
+};
+type PortalNavigation = {
+    show_ai_search: boolean;
+    show_header: boolean;
+    show_search: boolean;
+};
+type PortalTheme = {
+    background: string;
+    font_body: string;
+    font_header: string;
+    foreground: string;
+    logo_height: number;
+    logo_url: string;
+    logo_width: number;
+    primary: string;
+};
+type Portal = {
+    color_scheme?: 'toggle' | 'light' | 'dark';
+    display: PortalDisplay;
+    layout: PortalLayout;
+    navigation: PortalNavigation;
+    theme: PortalTheme;
+};
+type ThemeColors = {
+    background: string;
+    border: string;
+    card: string;
+    "card-foreground": string;
+    destructive: string;
+    "destructive-foreground": string;
+    foreground: string;
+    input: string;
+    muted: string;
+    "muted-foreground": string;
+    popover: string;
+    "popover-foreground": string;
+    primary: string;
+    "primary-foreground": string;
+    ring: string;
+    secondary: string;
+    "secondary-foreground": string;
+};
+type ThemeConfig = {
+    dark: ThemeColors;
+    light: ThemeColors;
+    radius: string;
+};
+type AccountAI = {
+    avatar_url: string;
+    enabled: boolean;
+    greeting: string;
+    name: string;
+};
+type Account = {
+    ai: AccountAI;
+    name: string;
+    slug: string;
+};
+type Settings = {
+    featured_playlists: Playlist[];
+    menu_items: MenuItem[];
+    ai_avatar: string;
+    ai_name: string;
+    ai_greeting?: string;
+    has_ai: boolean;
+    account: Account;
+    favicon_url?: string;
+    logo_dark_url?: string;
+    logo_url?: string;
+    meta_data: {
+        channel_name: string;
+        description: string;
+        image: string | null;
+        no_seo: boolean;
+        social_graph_image_url?: string;
+        title: string;
+        title_suffix: string;
+    };
+    portal: Portal;
+    theme_config: ThemeConfig;
+    version: string;
+};
+
+type ClientOptions = {
+    baseURL?: string;
+    debug: boolean;
+};
+declare function createClient(apiKey: string, options?: ClientOptions): {
+    settings: (videoLimit?: number) => Promise<{
+        data: Settings;
+    }>;
+    videos: {
+        list: (videoLimit?: number) => Promise<{
+            data: Video[];
+        }>;
+        get: (id: string) => Promise<{
+            data: Video;
+        }>;
+        search: (term: string) => Promise<{
+            data: Video[];
+        }>;
+    };
+    playlists: {
+        list: () => Promise<{
+            data: Playlist[];
+        }>;
+        get: (id: string) => Promise<{
+            data: Playlist;
+        }>;
+    };
+    trackEvent: (video: any, event: Event) => void;
+    trackPageView: (title: string) => void;
+};
+
+export { Account, AccountAI, AssistantConfig, MenuItem, Playlist, Portal, PortalDisplay, PortalLayout, PortalNavigation, PortalTheme, Settings, ThemeColors, ThemeConfig, Video, VideoAttachment, VideoDownloadUrls, VideoMetadata, VideoSubtitles, VideoTranscript, createClient };