web-mojo 2.1.46

package/dist/docit.es.js

@@ -0,0 +1,959 @@
+import { V as View, W as WebApp } from "./chunks/WebApp-B6mgbNn2.js";
+import { B, b, a, c, e, f } from "./chunks/WebApp-B6mgbNn2.js";
+import { T as TopNav } from "./chunks/TopNav-D3I3_25f.js";
+import { P as Page } from "./chunks/Page-B524zSQs.js";
+import { C as ContextMenu } from "./chunks/ContextMenu-BrHqj0fn.js";
+import { M as Model, C as Collection, T as ToastService, U as User } from "./chunks/User-DwIT-CTQ.js";
+import { T as TokenManager } from "./chunks/TokenManager-BXNva8Jk.js";
+class DocNavSidebar extends View {
+  constructor(options = {}) {
+    super({
+      className: "docit-sidebar-nav",
+      tagName: "nav",
+      ...options
+    });
+    this.singleBookMode = options.singleBookMode || false;
+    this.books = options.books;
+    this.docPages = options.docPages;
+    this.activeUser = options.activeUser;
+    this.currentBook = null;
+    this.currentDocPage = null;
+  }
+  async onInit() {
+    await super.onInit();
+    this.getApp().events.on("page:show", this._onPageShow.bind(this));
+  }
+  async _onPageShow({ query }) {
+    const bookSlug = query.doc_book;
+    const pageSlug = query.doc_page;
+    const app = this.getApp();
+    if (bookSlug) {
+      const book = this.books.findWhere({ slug: bookSlug });
+      if (book && (!this.currentBook || this.currentBook.id !== book.id)) {
+        await app.setActiveBook(book);
+        this.currentBook = app.currentBook;
+      }
+    } else {
+      if (this.currentBook) {
+        await app.setActiveBook(null);
+        this.currentBook = null;
+      }
+    }
+    this.currentDocPage = pageSlug ? this.docPages.findWhere({ slug: pageSlug }) : null;
+    this.render();
+  }
+  getTemplate() {
+    return `
+            <div class="docit-nav-body pt-3">
+                {{#currentBook}}
+                    {{#docPages.models}}
+                    <a href="#" class="docit-page-link {{#isActive}}active{{/isActive}}"
+                       data-action="select-page" data-page-slug="{{slug}}">
+                        <i class="{{#metadata.icon}}{{metadata.icon}}{{/metadata.icon}}{{^metadata.icon}}bi bi-file-earmark-text{{/metadata.icon}} me-2"></i>
+                        <span>{{title|capitalize}}</span>
+                    </a>
+                    {{/docPages.models}}
+                    {{^docPages.models}}
+                    <div class="docit-nav-empty"><p>No pages in this book.</p></div>
+                    {{/docPages.models}}
+                {{/currentBook}}
+                {{^currentBook}}
+                    {{#books.models}}
+                    <a href="#" class="docit-book-item" data-action="select-book" data-book-slug="{{slug}}">
+                        <i class="bi bi-book me-2"></i>
+                        <span class="book-title">{{title}}</span>
+                        <span class="badge bg-secondary ms-auto">{{page_count}}</span>
+                    </a>
+                    {{/books.models}}
+                {{/currentBook}}
+            </div>
+            {{#currentBook}}
+            <div class="docit-nav-footer">
+                {{#canEdit}}
+                <button class="btn btn-link w-100 mb-2" data-action="create-page">
+                    <i class="bi bi-plus-circle me-2"></i>
+                    Create New Page
+                </button>
+                {{/canEdit}}
+                <button class="btn btn-link w-100" data-action="back-to-books">
+                    <i class="bi bi-arrow-left me-2"></i>
+                    Back to Books
+                </button>
+            </div>
+            {{/currentBook}}
+            {{^currentBook}}
+                {{#canEdit}}
+                <div class="docit-nav-footer">
+                    <button class="btn btn-link w-100" data-action="create-book">
+                        <i class="bi bi-plus-circle me-2"></i>
+                        Create New Book
+                    </button>
+                </div>
+                {{/canEdit}}
+            {{/currentBook}}
+        `;
+  }
+  async onBeforeRender() {
+    await super.onBeforeRender();
+    this.canEdit = this.getApp().canEdit();
+    if (this.docPages && this.currentDocPage) {
+      this.docPages.forEach((page) => {
+        page.isActive = page.id === this.currentDocPage.id;
+      });
+    }
+  }
+  async onActionSelectBook(event, element) {
+    event.preventDefault();
+    const bookSlug = element.dataset.bookSlug;
+    const book = this.books.findWhere({ slug: bookSlug });
+    if (book) {
+      await this.getApp().setActiveBook(book);
+      const firstPage = this.docPages.at(0);
+      const query = { doc_book: book.get("slug") };
+      if (firstPage) {
+        query.doc_page = firstPage.get("slug");
+      }
+      this.getApp().showPage("docs", query, {});
+    }
+  }
+  onActionSelectPage(event, element) {
+    event.preventDefault();
+    const pageSlug = element.dataset.pageSlug;
+    if (this.currentBook && pageSlug) {
+      this.getApp().showPage("docs", {
+        doc_book: this.currentBook.get("slug"),
+        doc_page: pageSlug
+      }, {});
+    }
+  }
+  async onActionBackToBooks(event, element) {
+    event.preventDefault();
+    await this.getApp().setActiveBook(null);
+    this.getApp().showPage("home");
+  }
+  async onActionCreateBook() {
+    await this.getApp().createNewBook();
+  }
+  async onActionCreatePage() {
+    if (this.currentBook) {
+      await this.getApp().createNewPage(this.currentBook);
+    }
+  }
+  setBooks(books) {
+    this.books = books;
+    this.render();
+  }
+  setDocPages(docPages) {
+    this.docPages = docPages;
+    this.render();
+  }
+  setCurrentBook(book) {
+    this.currentBook = book;
+    this.render();
+    if (this.getApp().topnav) {
+      if (book) {
+        this.getApp().topnav.setBrand(book.get("title"));
+      } else {
+        this.getApp().topnav.setBrand("Documentation");
+      }
+    }
+  }
+  setUser(user) {
+    this.activeUser = user;
+    this.render();
+  }
+}
+class DocHomePage extends Page {
+  constructor(options = {}) {
+    super({
+      pageName: "home",
+      title: "Documentation",
+      className: "docit-home-page",
+      ...options
+    });
+  }
+  async getTemplate() {
+    return `
+            <div class="docit-empty-state vh-100 d-flex flex-column align-items-center justify-content-center">
+                <i class="bi bi-collection" style="font-size: 4rem;"></i>
+                <h3 class="mt-4">Welcome to the Documentation Portal</h3>
+                <p class="text-muted">Please select a book from the sidebar to get started.</p>
+            </div>
+        `;
+  }
+}
+class DocitBook extends Model {
+  static endpoint = "/api/docit/book";
+  buildUrl(id = null) {
+    if (this.get("slug") && !this.id) {
+      return `/api/docit/book/slug/${this.get("slug")}`;
+    } else if (this.id) {
+      return `/api/docit/book/${this.id}`;
+    }
+    return this.endpoint;
+  }
+}
+class DocitBookList extends Collection {
+  constructor(options = {}) {
+    super({
+      ModelClass: DocitBook,
+      endpoint: "/api/docit/book",
+      ...options
+    });
+  }
+  /**
+   * Custom parsing to handle the specific API response structure for book lists.
+   */
+  parse(response) {
+    if (response.data && response.data.status) {
+      this.meta = {
+        ...this.meta,
+        total: response.data.count || 0,
+        graph: response.data.graph
+      };
+      return response.data.data || [];
+    }
+    return super.parse(response);
+  }
+}
+class DocitPage extends Model {
+  static endpoint = "/api/docit/page";
+  buildUrl(id = null) {
+    if (this.get("slug") && !this.id) {
+      return `/api/docit/page/slug/${this.get("slug")}`;
+    } else if (this.id) {
+      return `/api/docit/page/${this.id}`;
+    }
+    return this.endpoint;
+  }
+}
+class DocitPageList extends Collection {
+  constructor(options = {}) {
+    super({
+      ModelClass: DocitPage,
+      endpoint: "/api/docit/page",
+      ...options
+    });
+  }
+  /**
+   * Custom parsing to handle the specific API response structure for page lists.
+   */
+  parse(response) {
+    if (response.data && response.data.status) {
+      this.meta = {
+        ...this.meta,
+        total: response.data.count || 0,
+        graph: response.data.graph,
+        book: response.data.book
+      };
+      return response.data.data || [];
+    }
+    return super.parse(response);
+  }
+}
+class DocPage extends Page {
+  constructor(options = {}) {
+    super({
+      pageName: "docs",
+      title: "Documentation",
+      className: "docit-page",
+      ...options
+    });
+    this.bookModel = null;
+    this.model = null;
+  }
+  async onInit() {
+    await super.onInit();
+    this.pageContextMenu = new ContextMenu({
+      config: this.getPageContextMenuConfig(),
+      containerId: "page-context-menu"
+    });
+    this.addChild(this.pageContextMenu);
+  }
+  getPageContextMenuConfig() {
+    return {
+      icon: "bi-three-dots",
+      buttonClass: "btn btn-outline-secondary btn-sm",
+      items: [
+        { label: "View History", action: "view-history", icon: "bi-clock-history" },
+        { type: "divider" },
+        { label: "Edit Page Content", action: "edit-page", icon: "bi-pencil" },
+        { label: "Edit Page Info", action: "edit-page-info", icon: "bi-list-ol" },
+        { type: "divider" },
+        { label: "Edit Book Info", action: "edit-book", icon: "bi-book" },
+        { type: "divider" },
+        { label: "Delete Page", action: "delete-page", icon: "bi-trash", danger: true }
+      ]
+    };
+  }
+  async getTemplate() {
+    return `
+            <div class="docit-page-container position-relative">
+                {{#loading}}
+                <div class="docit-loading">
+                    <div class="spinner-border" role="status">
+                        <span class="visually-hidden">Loading...</span>
+                    </div>
+                </div>
+                {{/loading}}
+
+                {{^loading}}
+                {{#model|bool}}
+                <div class="docit-page-toolbar">
+                <div class="row">
+                    <div class="col d-flex justify-content-end">
+                        <div data-container="page-context-menu"></div>
+                    </div>
+                </div>
+                </div>
+                <article class="docit-page-content">
+                    {{{model.html}}}
+                </article>
+
+                <nav class="docit-page-nav">
+                    {{#prevPage}}
+                    <a href="#" class="docit-nav-prev" data-action="navigate-to-page" data-page-slug="{{slug}}">
+                        <i class="bi bi-arrow-left"></i>
+                        <div>
+                            <small>Previous</small>
+                            <span>{{title}}</span>
+                        </div>
+                    </a>
+                    {{/prevPage}}
+                    {{^prevPage}}
+                    <div></div>
+                    {{/prevPage}}
+
+                    {{#nextPage}}
+                    <a href="#" class="docit-nav-next" data-action="navigate-to-page" data-page-slug="{{slug}}">
+                        <div>
+                            <small>Next</small>
+                            <span>{{title}}</span>
+                        </div>
+                        <i class="bi bi-arrow-right"></i>
+                    </a>
+                    {{/nextPage}}
+
+                    <div class="my-3">
+                        <span class="text-muted">Last updated: {{model.modified|datetime}}</span>
+                    </div>
+                </nav>
+                {{/model|bool}}
+
+                {{^model|bool}}
+                <div class="docit-empty-state">
+                    <i class="bi bi-file-earmark-text"></i>
+                    <h3>Select a page</h3>
+                    <p>Choose a page from the sidebar to view its content.</p>
+                </div>
+                {{/model|bool}}
+                {{/loading}}
+            </div>
+        `;
+  }
+  async onParams(params = {}, query = {}) {
+    await super.onParams(params, query);
+    this.loading = true;
+    await this.render();
+    const app = this.getApp();
+    const bookSlug = app.bookSlug || query.doc_book;
+    const pageSlug = query.doc_page;
+    if (!bookSlug) {
+      setTimeout(() => {
+        app.showPage("home");
+      }, 100);
+      return;
+    }
+    try {
+      if (bookSlug) {
+        if (!app.currentBook || app.currentBook.get("slug") !== bookSlug) {
+          const book = new DocitBook({ slug: bookSlug });
+          await book.fetch();
+          await app.setActiveBook(book);
+        }
+        this.bookModel = app.currentBook;
+        if (pageSlug) {
+          this.model = new DocitPage({ slug: pageSlug });
+          await this.model.fetch({ graph: "html" });
+        } else {
+          const firstPage = app.docPages.at(0);
+          if (firstPage) {
+            this.model = new DocitPage({ id: firstPage.id });
+            await this.model.fetch({ graph: "html" });
+          } else {
+            this.model = null;
+          }
+        }
+      } else {
+        this.bookModel = null;
+        this.model = null;
+      }
+      this.canEdit = app.canEdit();
+      this.setupNavigation();
+    } catch (error) {
+      console.error("Failed to load page:", error);
+      this.showError("Failed to load documentation page");
+      this.model = null;
+    } finally {
+      this.loading = false;
+      await this.render();
+      app.events.emit("docit:page-rendered", {
+        book: this.bookModel,
+        page: this.model
+      });
+    }
+  }
+  setupNavigation() {
+    if (!this.model) {
+      this.prevPage = null;
+      this.nextPage = null;
+      return;
+    }
+    const app = this.getApp();
+    const pages = app.docPages.models;
+    const currentIndex = pages.findIndex((p) => p.id === this.model.id);
+    this.prevPage = currentIndex > 0 ? { slug: pages[currentIndex - 1].get("slug"), title: pages[currentIndex - 1].get("title") } : null;
+    this.nextPage = currentIndex < pages.length - 1 ? { slug: pages[currentIndex + 1].get("slug"), title: pages[currentIndex + 1].get("title") } : null;
+  }
+  async onActionNavigateToPage(event, element) {
+    event.preventDefault();
+    const pageSlug = element.dataset.pageSlug;
+    if (pageSlug) {
+      this.getApp().showPage("docs", {}, {
+        doc_book: this.bookModel.get("slug"),
+        doc_page: pageSlug
+      });
+    }
+  }
+  async onActionEditPage(event, element) {
+    event.preventDefault();
+    if (this.model) {
+      this.getApp().showPage("edit", {
+        id: this.model.id,
+        doc_book: this.bookModel.get("slug"),
+        doc_page: this.model.get("slug")
+      }, {});
+    }
+  }
+  async onActionViewHistory(event, element) {
+    this.showInfo("Revision history coming soon.");
+  }
+  async onActionEditPageInfo(event, element) {
+    if (this.model) {
+      this.getApp().showModelForm({
+        model: this.model,
+        fields: [
+          { label: "Title", name: "title", type: "text" },
+          { label: "Order Priority", name: "order_priority" },
+          { label: "Slug", name: "slug" }
+        ]
+      });
+    }
+  }
+  async onActionEditBook(event, element) {
+    if (this.model) {
+      const book = this.getApp().sidebar.currentBook;
+      if (!book) return;
+      this.getApp().showModelForm({
+        model: book,
+        fields: [
+          { label: "Title", name: "title", type: "text" },
+          { label: "Order Priority", name: "order_priority" },
+          { label: "Slug", name: "slug" },
+          { label: "Is Active", name: "is_active", type: "switch" }
+        ]
+      });
+    }
+  }
+  async onActionDeletePage(event, element) {
+    if (!this.model) return;
+    const confirmed = await this.getApp().showConfirm({
+      title: "Delete Page",
+      body: `Are you sure you want to delete "${this.model.get("title")}"?`,
+      confirmText: "Delete",
+      confirmClass: "btn-danger"
+    });
+    if (confirmed) {
+      await this.model.destroy();
+      this.showSuccess("Page deleted.");
+      await this.getApp().setActiveBook(this.bookModel);
+      const firstPage = this.getApp().docPages.at(0);
+      if (firstPage) {
+        this.getApp().showPage("docs", {}, { doc_book: this.bookModel.get("slug"), doc_page: firstPage.get("slug") });
+      } else {
+        this.getApp().showPage("docs", {}, { doc_book: this.bookModel.get("slug") });
+      }
+    }
+  }
+  async onAfterRender() {
+    await super.onAfterRender();
+    if (typeof Prism !== "undefined" && this.model) {
+      Prism.highlightAll();
+    }
+  }
+}
+class DocEditPage extends Page {
+  constructor(options = {}) {
+    super({
+      pageName: "edit",
+      title: "Edit Page",
+      className: "docit-edit-page",
+      ...options
+    });
+    this.model = null;
+    this.editor = null;
+    this.isDirty = false;
+  }
+  async getTemplate() {
+    return `
+            <div class="docit-edit-container vh-100">
+                {{#loading}}
+                <div class="docit-loading"><div class="spinner-border"></div></div>
+                {{/loading}}
+
+                {{^loading}}{{#model}}
+                <header class="docit-edit-header">
+                    <div class="docit-edit-title-row">
+                        <h2>Editing: {{model.title}}</h2>
+                        <div class="docit-edit-actions">
+                            <button class="btn btn-outline-secondary" data-action="cancel-edit">Cancel</button>
+                            <button class="btn btn-success" data-action="save-page">
+                                <i class="bi bi-check-lg"></i> Save Changes
+                            </button>
+                        </div>
+                    </div>
+                </header>
+                <div class="docit-edit-body flex-grow-1">
+                    <div id="editor"></div>
+                </div>
+                {{/model}}
+                {{^model}}
+                <div class="docit-error-state">
+                    <h3>Page Not Found</h3>
+                    <p>The page you're trying to edit could not be found.</p>
+                    <button class="btn btn-primary" data-action="go-back">Go Back</button>
+                </div>
+                {{/model}}{{/loading}}
+            </div>
+        `;
+  }
+  async onParams(params = {}, query = {}) {
+    await super.onParams(params, query);
+    let model = null;
+    if (query.id) {
+      model = new DocitPage({ id: query.id });
+    } else if (query.doc_page) {
+      model = new DocitPage({ slug: query.doc_page });
+    }
+    this.model = model;
+    if (this.model) {
+      await this.model.fetch({ graph: "detail" });
+    }
+  }
+  initEditor() {
+    if (this.editor || !this.element.querySelector("#editor")) return;
+    this.editor = new toastui.Editor({
+      el: this.element.querySelector("#editor"),
+      height: "100%",
+      initialEditType: "markdown",
+      previewStyle: "tab",
+      initialValue: this.model.get("content") || ""
+    });
+    this.editor.on("change", () => {
+      this.isDirty = true;
+    });
+  }
+  async onActionSavePage() {
+    if (!this.model || !this.editor) return;
+    this.saving = true;
+    this.getApp().showLoading("saving...");
+    try {
+      const content = this.editor.getMarkdown();
+      await this.model.save({ content });
+      this.isDirty = false;
+      this.getApp().toast.success("Page saved successfully.");
+      this.getApp().showPage("docs", this.query);
+    } catch (error) {
+      console.error("Failed to save page:", error);
+      this.getApp().toast.error("Failed to save page.");
+    } finally {
+      this.saving = false;
+      this.getApp().hideLoading();
+    }
+  }
+  async onActionCancelEdit() {
+    this.getApp().showPage("docs", this.query);
+  }
+  onActionGoBack() {
+    this.getApp().showPage("docs");
+  }
+  async onBeforeRender() {
+    await super.onBeforeRender();
+    if (this.editor) {
+      this.editor.destroy();
+      this.editor = null;
+    }
+  }
+  async onAfterRender() {
+    await super.onAfterRender();
+    if (this.model) {
+      this.initEditor();
+    }
+  }
+  async onBeforeDestroy() {
+    this.editor?.destroy();
+    await super.onBeforeDestroy();
+  }
+}
+class DocItApp extends WebApp {
+  constructor(config = {}) {
+    const defaults = {
+      name: config.title || "DocIt Portal",
+      version: config.version || "1.0.0",
+      debug: config.debug || false,
+      container: config.container || "#app",
+      defaultRoute: "home",
+      basePath: config.basePath || "",
+      ...config
+    };
+    super(defaults);
+    this.bookSlug = config.bookSlug || null;
+    this.showBookNav = config.showBookNav !== void 0 ? config.showBookNav : !this.bookSlug;
+    this.theme = config.theme || "light";
+    this.editPermissions = config.permissions?.edit || ["manage_docit"];
+    this.sidebarConfig = {
+      showSearch: true,
+      defaultCollapsed: false,
+      ...config.sidebar
+    };
+    this.books = new DocitBookList();
+    this.books.params.sort = "-order_priority";
+    this.docPages = new DocitPageList();
+    this.docPages.params.sort = "-order_priority";
+    this.toast = new ToastService();
+    this.currentBook = null;
+    this.sidebar = null;
+    this.isDocItReady = false;
+    this.tokenManager = new TokenManager();
+    this.activeUser = null;
+  }
+  /**
+   * Start the DocIt application
+   */
+  async start() {
+    try {
+      console.log("Starting DocIt Portal...");
+      this.setupDocItLayout();
+      await this.setupTopNav();
+      await this.setupSidebar();
+      await this.checkAuthStatus();
+      this.registerDocItPages();
+      await super.start();
+      await this.loadInitialData();
+      this.isDocItReady = true;
+      this.events.emit("docit:ready", { app: this });
+      console.log("✅ DocIt Portal ready");
+    } catch (error) {
+      console.error("Failed to start DocIt:", error);
+      this.showError("Failed to initialize documentation portal");
+      throw error;
+    }
+  }
+  /**
+   * Setup DocIt specific layout
+   */
+  setupDocItLayout() {
+    const container = typeof this.container === "string" ? document.querySelector(this.container) : this.container;
+    if (!container) {
+      throw new Error(`Container not found: ${this.container}`);
+    }
+    container.classList.add("docit-app", `docit-theme-${this.theme}`);
+    container.innerHTML = `
+            <div class="docit-app-layout">
+                <div id="topnav-container"></div>
+                <div class="docit-body-layout">
+                    <div class="docit-sidebar" id="docit-sidebar"></div>
+                    <div class="docit-main">
+                        <div class="docit-content" id="page-container"></div>
+                    </div>
+                </div>
+            </div>
+        `;
+    this.pageContainer = "#page-container";
+  }
+  async setupTopNav() {
+    this.topnav = new TopNav({
+      containerId: "topnav-container",
+      brand: this.name,
+      theme: "navbar navbar-expand-lg bg-dark navbar-dark",
+      showSidebarToggle: false,
+      displayMode: "brand",
+      rightItems: [
+        {
+          id: "login",
+          icon: "bi-box-arrow-in-right",
+          href: "/examples/auth/",
+          label: "Login"
+        }
+      ],
+      userMenu: {
+        label: "User",
+        icon: "bi-person-circle",
+        items: [
+          {
+            label: "Profile",
+            icon: "bi-person",
+            action: "profile"
+          },
+          {
+            divider: true
+          },
+          {
+            label: "Logout",
+            icon: "bi-box-arrow-right",
+            action: "logout"
+          }
+        ]
+      }
+    });
+    await this.topnav.render();
+  }
+  onActionToggleSidebar() {
+    const layout = document.querySelector(".docit-layout");
+    layout.classList.toggle("sidebar-collapsed");
+  }
+  /**
+   * Setup sidebar navigation
+   */
+  async setupSidebar() {
+    this.sidebar = new DocNavSidebar({
+      containerId: "docit-sidebar",
+      app: this,
+      singleBookMode: !!this.bookSlug,
+      showBookNav: this.showBookNav,
+      books: this.books,
+      docPages: this.docPages,
+      activeUser: this.activeUser,
+      ...this.sidebarConfig
+    });
+    await this.sidebar.render();
+  }
+  /**
+   * Register DocIt pages
+   */
+  registerDocItPages() {
+    this.registerPage("home", DocHomePage, {
+      route: "/",
+      permissions: null
+    });
+    this.registerPage("docs", DocPage, {
+      route: "/docs",
+      permissions: null
+      // Public access
+    });
+    this.registerPage("edit", DocEditPage, {
+      route: "/edit",
+      permissions: this.editPermissions
+    });
+  }
+  /**
+   * Load initial data based on mode
+   */
+  async loadInitialData() {
+    try {
+      if (this.bookSlug) {
+        const book = new DocitBook({ slug: this.bookSlug });
+        await book.fetch();
+        if (book.id) {
+          this.books.add(book);
+          await this.setActiveBook(book);
+        } else {
+          throw new Error(`Book with slug '${this.bookSlug}' not found.`);
+        }
+      } else {
+        await this.books.fetch({ graph: "list" });
+        this.sidebar.render();
+      }
+    } catch (error) {
+      console.error("Failed to load initial data:", error);
+      this.showError("Failed to load documentation");
+    }
+  }
+  /**
+   * Set the active book and load its pages
+   * @param {DocitBook} book - The book to set as active
+   */
+  async setActiveBook(book) {
+    if (this.currentBook && book && this.currentBook.id === book.id) {
+      return;
+    }
+    this.currentBook = book;
+    this.docPages.reset();
+    if (book) {
+      await this.docPages.fetch({
+        book: book.get("id"),
+        graph: "list"
+      });
+    }
+    this.sidebar.setCurrentBook(book);
+    this.sidebar.setDocPages(this.docPages);
+    this.events.emit("docit:book-changed", { book });
+  }
+  /**
+   * Save doc page content using Model
+   */
+  async saveDocPageContent(docPageId, content) {
+    const docPage = this.docPages.get(docPageId) || new DocitPage({ id: docPageId });
+    docPage.set("content", content);
+    const response = await docPage.save();
+    if (!response.success || !response.data.status) {
+      throw new Error("Failed to save doc page");
+    }
+    return docPage;
+  }
+  /**
+   * Check if user can edit
+   */
+  canEdit() {
+    const user = this.activeUser;
+    if (!user) return false;
+    return this.editPermissions.some((perm) => user.hasPermission ? user.hasPermission(perm) : false);
+  }
+  /**
+   * Check authentication status and load user
+   */
+  async checkAuthStatus() {
+    try {
+      const token = this.tokenManager.getTokenInstance();
+      if (!token || !token.isValid()) {
+        this.events.emit("auth:unauthorized", { app: this });
+        return;
+      }
+      if (token.isExpired()) {
+        this.events.emit("auth:expired", { app: this });
+        return;
+      }
+      this.tokenManager.startAutoRefresh(this);
+      this.rest.setAuthToken(token.token);
+      const user = new User({ id: token.getUserId() });
+      await user.fetch();
+      this.setActiveUser(user);
+    } catch (error) {
+      console.error("Failed to check auth status:", error);
+      this.events.emit("auth:error", { error, app: this });
+    }
+  }
+  /**
+   * Set the active authenticated user
+   */
+  setActiveUser(user) {
+    this.activeUser = user;
+    if (this.sidebar) {
+      this.sidebar.setUser(user);
+    }
+    if (this.topnav) {
+      this.topnav.setUser(user);
+      this.tonnav.render();
+    }
+    this.events.emit("user:changed", { user, app: this });
+    return this;
+  }
+  /**
+   * Clear the active user (logout)
+   */
+  clearActiveUser() {
+    this.activeUser = null;
+    this.tokenManager.clearTokens();
+    this.rest.clearAuth();
+    if (this.sidebar) {
+      this.sidebar.setUser(null);
+    }
+    this.events.emit("user:cleared", { app: this });
+    return this;
+  }
+  /**
+   * Handle logout
+   */
+  async logout() {
+    this.clearActiveUser();
+    this.books.reset();
+    this.docPages.reset();
+    this.currentBook = null;
+    this.events.emit("auth:logout", { app: this });
+    window.location.reload();
+  }
+  async createNewBook() {
+    const result = await this.showModelForm({
+      title: "Create New Book",
+      model: new DocitBook(),
+      fields: [
+        { name: "title", label: "Title", required: true },
+        { name: "slug", label: "Slug", required: true, helpText: "A URL-friendly identifier." }
+      ]
+    });
+    if (result && result.success) {
+      this.books.add(result.data);
+      this.sidebar.render();
+      this.showSuccess("Book created successfully.");
+    }
+  }
+  async createNewPage(book) {
+    if (!book) return;
+    const data = await this.showForm({
+      title: "Create New Page",
+      fields: [
+        { name: "title", label: "Title", required: true },
+        { name: "slug", label: "Slug", required: true, helpText: "A URL-friendly identifier." }
+      ]
+    });
+    if (data && data.slug) {
+      data.book = book.id;
+    }
+    const newPage = new DocitPage();
+    const result = await newPage.save(data);
+    if (result && result.success) {
+      this.docPages.add(newPage);
+      this.sidebar.render();
+      this.showPage("edit", {
+        id: newPage.id,
+        doc_book: book.get("slug"),
+        doc_page: newPage.get("slug")
+      }, {});
+    }
+  }
+  /**
+   * Static factory method for quick setup
+   */
+  static create(config = {}) {
+    return new DocItApp(config);
+  }
+  /**
+   * Quick setup for single-book mode
+   */
+  static createForBook(bookSlug, config = {}) {
+    return new DocItApp({
+      ...config,
+      bookSlug,
+      showBookNav: false
+    });
+  }
+}
+export {
+  B as BUILD_TIME,
+  DocEditPage,
+  DocHomePage,
+  DocItApp,
+  DocNavSidebar,
+  DocPage,
+  DocitBook,
+  DocitBookList,
+  DocitPage,
+  DocitPageList,
+  b as VERSION,
+  a as VERSION_INFO,
+  c as VERSION_MAJOR,
+  e as VERSION_MINOR,
+  f as VERSION_REVISION,
+  WebApp
+};
+//# sourceMappingURL=docit.es.js.map