@sybil-studio-devs/sdk 0.1.0 → 0.2.0

package/dist/atlas/index.d.mts

@@ -0,0 +1,28 @@
+import { f as AtlasEmbedConfig, k as AtlasInstance, d as AtlasSidebarData, a as AtlasPage, C as CreateAtlasPageParams, U as UpdateAtlasPageParams, i as AtlasLogEntry } from '../types-BjxgQxBW.mjs';
+export { m as AtlasAPIError, l as AtlasAPIResponse, b as AtlasBlock, j as AtlasError, g as AtlasFeatures, h as AtlasLoggingConfig, e as AtlasSidebarPage, c as AtlasTeamspace, A as AtlasTheme } from '../types-BjxgQxBW.mjs';
+
+declare function embedAtlas(config: AtlasEmbedConfig): AtlasInstance;
+declare class AtlasClient {
+    private apiKey;
+    private baseUrl;
+    private workspaceId;
+    private logger;
+    constructor(config: {
+        apiKey: string;
+        workspaceId: string;
+        baseUrl?: string;
+        logging?: AtlasEmbedConfig['logging'];
+    });
+    private request;
+    getSidebar(): Promise<AtlasSidebarData>;
+    getPage(pageId: string): Promise<AtlasPage>;
+    createPage(params?: CreateAtlasPageParams): Promise<AtlasPage>;
+    updatePage(pageId: string, params: UpdateAtlasPageParams): Promise<AtlasPage>;
+    deletePage(pageId: string): Promise<void>;
+    exportPage(pageId: string, format: 'pdf' | 'docx' | 'md'): Promise<Blob>;
+    toggleFavorite(pageId: string): Promise<AtlasPage>;
+    getLogs(): AtlasLogEntry[];
+    clearLogs(): void;
+}
+
+export { AtlasClient, AtlasEmbedConfig, AtlasInstance, AtlasLogEntry, AtlasPage, AtlasSidebarData, CreateAtlasPageParams, UpdateAtlasPageParams, embedAtlas };

package/dist/atlas/index.d.ts

@@ -0,0 +1,28 @@
+import { f as AtlasEmbedConfig, k as AtlasInstance, d as AtlasSidebarData, a as AtlasPage, C as CreateAtlasPageParams, U as UpdateAtlasPageParams, i as AtlasLogEntry } from '../types-BjxgQxBW.js';
+export { m as AtlasAPIError, l as AtlasAPIResponse, b as AtlasBlock, j as AtlasError, g as AtlasFeatures, h as AtlasLoggingConfig, e as AtlasSidebarPage, c as AtlasTeamspace, A as AtlasTheme } from '../types-BjxgQxBW.js';
+
+declare function embedAtlas(config: AtlasEmbedConfig): AtlasInstance;
+declare class AtlasClient {
+    private apiKey;
+    private baseUrl;
+    private workspaceId;
+    private logger;
+    constructor(config: {
+        apiKey: string;
+        workspaceId: string;
+        baseUrl?: string;
+        logging?: AtlasEmbedConfig['logging'];
+    });
+    private request;
+    getSidebar(): Promise<AtlasSidebarData>;
+    getPage(pageId: string): Promise<AtlasPage>;
+    createPage(params?: CreateAtlasPageParams): Promise<AtlasPage>;
+    updatePage(pageId: string, params: UpdateAtlasPageParams): Promise<AtlasPage>;
+    deletePage(pageId: string): Promise<void>;
+    exportPage(pageId: string, format: 'pdf' | 'docx' | 'md'): Promise<Blob>;
+    toggleFavorite(pageId: string): Promise<AtlasPage>;
+    getLogs(): AtlasLogEntry[];
+    clearLogs(): void;
+}
+
+export { AtlasClient, AtlasEmbedConfig, AtlasInstance, AtlasLogEntry, AtlasPage, AtlasSidebarData, CreateAtlasPageParams, UpdateAtlasPageParams, embedAtlas };

package/dist/atlas/index.js

@@ -0,0 +1,418 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/atlas/index.ts
+var atlas_exports = {};
+__export(atlas_exports, {
+  AtlasClient: () => AtlasClient,
+  embedAtlas: () => embedAtlas
+});
+module.exports = __toCommonJS(atlas_exports);
+
+// src/atlas/client.ts
+var DEFAULT_BASE_URL = "https://app.sybil.studio";
+var AtlasLogger = class {
+  constructor(config) {
+    this.logs = [];
+    this.config = config;
+  }
+  log(level, category, message, data, duration) {
+    if (!this.config?.enabled) return;
+    const levels = ["debug", "info", "warn", "error"];
+    const configLevel = this.config.level || "info";
+    if (levels.indexOf(level) < levels.indexOf(configLevel)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      category,
+      message,
+      data,
+      duration
+    };
+    this.logs.push(entry);
+    this.config.onLog?.(entry);
+    if (typeof console !== "undefined") {
+      const prefix = `[Atlas SDK] [${category}]`;
+      switch (level) {
+        case "debug":
+          console.debug(prefix, message, data || "");
+          break;
+        case "info":
+          console.info(prefix, message, data || "");
+          break;
+        case "warn":
+          console.warn(prefix, message, data || "");
+          break;
+        case "error":
+          console.error(prefix, message, data || "");
+          break;
+      }
+    }
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+};
+function embedAtlas(config) {
+  const {
+    apiKey,
+    workspaceId,
+    container,
+    baseUrl = DEFAULT_BASE_URL,
+    theme = "dark",
+    showSidebar = true,
+    sidebarWidth = 260,
+    sidebarCollapsible = true,
+    readOnly = false,
+    defaultPageId,
+    allowCreate = true,
+    allowDelete = true,
+    allowExport = true,
+    features = {},
+    logging,
+    onReady,
+    onPageChange,
+    onPageCreate,
+    onPageDelete,
+    onPageUpdate,
+    onError,
+    onNavigate
+  } = config;
+  const logger = new AtlasLogger(logging);
+  const startTime = Date.now();
+  logger.log("info", "render", "Initializing Atlas embed", {
+    workspaceId,
+    showSidebar,
+    readOnly,
+    features
+  });
+  const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+  if (!containerEl) {
+    const error = {
+      code: "CONTAINER_NOT_FOUND",
+      message: "Container element not found",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onError?.(error);
+    throw new Error(error.message);
+  }
+  const params = new URLSearchParams({
+    apiKey,
+    workspaceId,
+    readOnly: readOnly.toString(),
+    showSidebar: showSidebar.toString(),
+    sidebarWidth: sidebarWidth.toString(),
+    sidebarCollapsible: sidebarCollapsible.toString(),
+    allowCreate: allowCreate.toString(),
+    allowDelete: allowDelete.toString(),
+    allowExport: allowExport.toString()
+  });
+  if (defaultPageId) params.set("defaultPageId", defaultPageId);
+  if (typeof theme === "string") {
+    params.set("theme", theme);
+  } else {
+    Object.entries(theme).forEach(([key, value]) => {
+      if (value) params.set(`theme_${key}`, value);
+    });
+  }
+  Object.entries(features).forEach(([key, value]) => {
+    if (typeof value === "boolean") {
+      params.set(`feature_${key}`, value.toString());
+    }
+  });
+  const iframe = document.createElement("iframe");
+  iframe.src = `${baseUrl}/embed/atlas?${params.toString()}`;
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "8px";
+  iframe.allow = "clipboard-write";
+  let currentPage = null;
+  let isReady = false;
+  const createError = (code, message, status) => ({
+    code,
+    message,
+    status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  });
+  const apiRequest = async (endpoint, options = {}) => {
+    const requestStart = Date.now();
+    const url = `${baseUrl}/api/sdk/v1${endpoint}`;
+    logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`, {
+      url,
+      method: options.method || "GET"
+    });
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+      const duration = Date.now() - requestStart;
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = createError(
+          errorData.error?.code || "API_ERROR",
+          errorData.error?.message || `Request failed with status ${response.status}`,
+          response.status
+        );
+        logger.log("error", "api", `Request failed: ${endpoint}`, {
+          status: response.status,
+          error: errorData
+        }, duration);
+        onError?.(error);
+        throw error;
+      }
+      const data = await response.json();
+      logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+      return data;
+    } catch (err) {
+      if (err.code) throw err;
+      const error = createError("NETWORK_ERROR", err.message);
+      logger.log("error", "api", "Network error", { error: err.message });
+      onError?.(error);
+      throw error;
+    }
+  };
+  const postMessage = (type, payload) => {
+    iframe.contentWindow?.postMessage({ type, ...payload }, baseUrl);
+  };
+  const handleMessage = (event) => {
+    if (event.origin !== new URL(baseUrl).origin) return;
+    const { type, ...data } = event.data || {};
+    logger.log("debug", "render", `Message received: ${type}`, data);
+    switch (type) {
+      case "sybil:atlas:ready":
+        isReady = true;
+        logger.log("info", "render", "Atlas embed ready", {}, Date.now() - startTime);
+        onReady?.(instance);
+        break;
+      case "sybil:atlas:page:changed":
+        currentPage = data.page;
+        logger.log("info", "navigation", "Page changed", { pageId: data.page?.id });
+        onPageChange?.(data.page);
+        break;
+      case "sybil:atlas:page:created":
+        logger.log("info", "editor", "Page created", { pageId: data.page?.id });
+        onPageCreate?.(data.page);
+        break;
+      case "sybil:atlas:page:deleted":
+        logger.log("info", "editor", "Page deleted", { pageId: data.pageId });
+        onPageDelete?.(data.pageId);
+        break;
+      case "sybil:atlas:page:updated":
+        currentPage = data.page;
+        logger.log("debug", "sync", "Page updated", { pageId: data.page?.id });
+        onPageUpdate?.(data.page);
+        break;
+      case "sybil:atlas:navigate":
+        logger.log("info", "navigation", "Navigation requested", { pageId: data.pageId });
+        onNavigate?.(data.pageId);
+        break;
+      case "sybil:atlas:error":
+        const error = createError(data.code || "EMBED_ERROR", data.message);
+        logger.log("error", "render", "Embed error", data);
+        onError?.(error);
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  containerEl.appendChild(iframe);
+  const instance = {
+    getPages: async () => {
+      logger.log("info", "api", "Fetching pages");
+      const response = await apiRequest(
+        `/atlas/workspaces/${workspaceId}/sidebar`
+      );
+      return response.sidebar;
+    },
+    getPage: async (pageId) => {
+      logger.log("info", "api", "Fetching page", { pageId });
+      const response = await apiRequest(
+        `/atlas/pages/${pageId}`
+      );
+      return response.page;
+    },
+    createPage: async (params2) => {
+      logger.log("info", "api", "Creating page", params2);
+      const response = await apiRequest(
+        `/atlas/workspaces/${workspaceId}/pages`,
+        {
+          method: "POST",
+          body: JSON.stringify(params2)
+        }
+      );
+      postMessage("sybil:atlas:refresh");
+      return response.page;
+    },
+    updatePage: async (pageId, params2) => {
+      logger.log("info", "api", "Updating page", { pageId, ...params2 });
+      const response = await apiRequest(
+        `/atlas/pages/${pageId}`,
+        {
+          method: "PUT",
+          body: JSON.stringify(params2)
+        }
+      );
+      postMessage("sybil:atlas:refresh");
+      return response.page;
+    },
+    deletePage: async (pageId) => {
+      logger.log("info", "api", "Deleting page", { pageId });
+      await apiRequest(`/atlas/pages/${pageId}`, { method: "DELETE" });
+      postMessage("sybil:atlas:refresh");
+    },
+    navigateTo: (pageId) => {
+      logger.log("info", "navigation", "Navigating to page", { pageId });
+      postMessage("sybil:atlas:navigate", { pageId });
+    },
+    getCurrentPage: () => currentPage,
+    exportPage: async (pageId, format) => {
+      logger.log("info", "api", "Exporting page", { pageId, format });
+      const response = await fetch(
+        `${baseUrl}/api/sdk/v1/atlas/pages/${pageId}/export?format=${format}`,
+        {
+          headers: { "x-api-key": apiKey }
+        }
+      );
+      if (!response.ok) {
+        const error = createError("EXPORT_FAILED", "Failed to export page");
+        onError?.(error);
+        throw error;
+      }
+      return response.blob();
+    },
+    toggleSidebar: () => {
+      logger.log("debug", "render", "Toggling sidebar");
+      postMessage("sybil:atlas:toggleSidebar");
+    },
+    setSidebarWidth: (width) => {
+      logger.log("debug", "render", "Setting sidebar width", { width });
+      postMessage("sybil:atlas:setSidebarWidth", { width });
+    },
+    setTheme: (newTheme) => {
+      logger.log("debug", "render", "Setting theme", { theme: newTheme });
+      postMessage("sybil:atlas:setTheme", { theme: newTheme });
+    },
+    refresh: async () => {
+      logger.log("info", "sync", "Refreshing");
+      postMessage("sybil:atlas:refresh");
+    },
+    destroy: () => {
+      logger.log("info", "render", "Destroying Atlas embed");
+      window.removeEventListener("message", handleMessage);
+      iframe.remove();
+    },
+    getLogs: () => logger.getLogs(),
+    clearLogs: () => logger.clearLogs()
+  };
+  return instance;
+}
+var AtlasClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.workspaceId = config.workspaceId;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.logger = new AtlasLogger(config.logging);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}/api/sdk/v1${endpoint}`;
+    const startTime = Date.now();
+    this.logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`);
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    const duration = Date.now() - startTime;
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      this.logger.log("error", "api", `Request failed: ${endpoint}`, {
+        status: response.status,
+        error: errorData
+      }, duration);
+      throw new Error(errorData.error?.message || `Request failed with status ${response.status}`);
+    }
+    this.logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+    return response.json();
+  }
+  async getSidebar() {
+    const response = await this.request(
+      `/atlas/workspaces/${this.workspaceId}/sidebar`
+    );
+    return response.sidebar;
+  }
+  async getPage(pageId) {
+    const response = await this.request(`/atlas/pages/${pageId}`);
+    return response.page;
+  }
+  async createPage(params = {}) {
+    const response = await this.request(
+      `/atlas/workspaces/${this.workspaceId}/pages`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+    return response.page;
+  }
+  async updatePage(pageId, params) {
+    const response = await this.request(
+      `/atlas/pages/${pageId}`,
+      { method: "PUT", body: JSON.stringify(params) }
+    );
+    return response.page;
+  }
+  async deletePage(pageId) {
+    await this.request(`/atlas/pages/${pageId}`, { method: "DELETE" });
+  }
+  async exportPage(pageId, format) {
+    const response = await fetch(
+      `${this.baseUrl}/api/sdk/v1/atlas/pages/${pageId}/export?format=${format}`,
+      { headers: { "x-api-key": this.apiKey } }
+    );
+    if (!response.ok) throw new Error("Failed to export page");
+    return response.blob();
+  }
+  async toggleFavorite(pageId) {
+    const response = await this.request(
+      `/atlas/pages/${pageId}/favorite`,
+      { method: "POST" }
+    );
+    return response.page;
+  }
+  getLogs() {
+    return this.logger.getLogs();
+  }
+  clearLogs() {
+    this.logger.clearLogs();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AtlasClient,
+  embedAtlas
+});

package/dist/atlas/index.mjs

@@ -0,0 +1,8 @@
+import {
+  AtlasClient,
+  embedAtlas
+} from "../chunk-B6RXZKRY.mjs";
+export {
+  AtlasClient,
+  embedAtlas
+};