@interactive-inc/docs-client 1.0.20 → 1.1.1

package/build/file-system-mock.d.ts

@@ -0,0 +1,112 @@
+import { D as DocFileSystemInterface, a as DocPathSystem } from './doc-file-system.interface-C5vpYrOL.js';
+
+/**
+ * In-memory file system for testing
+ */
+declare class DocFileSystemMock implements DocFileSystemInterface {
+    private files;
+    private readonly pathSystem;
+    private readonly basePath;
+    constructor(props: {
+        basePath: string;
+        pathSystem?: DocPathSystem;
+        skipDefaultFiles?: boolean;
+    });
+    /**
+     * PathSystem accessor (for testing)
+     */
+    getPathSystem(): DocPathSystem;
+    /**
+     * Get file name from path
+     */
+    readFileName(relativePath: string): string;
+    /**
+     * Get file extension from path
+     */
+    readFileExtension(relativePath: string): string;
+    /**
+     * Get directory path where the file exists
+     */
+    readFileDirectory(relativePath: string): string;
+    /**
+     * Get base path
+     */
+    getBasePath(): string;
+    /**
+     * Convert relative path to absolute path
+     */
+    resolve(relativePath: string): string;
+    /**
+     * Normalize path using basePath
+     */
+    private normalizePath;
+    /**
+     * Create instance (mock data is automatically loaded)
+     */
+    static create(basePath?: string): DocFileSystemMock;
+    /**
+     * Factory method for testing
+     */
+    static createWithFiles(props: {
+        basePath?: string;
+        fileContents?: Record<string, string>;
+    }): DocFileSystemMock;
+    readFile(filePath: string): Promise<string | null | Error>;
+    writeFile(filePath: string, content: string): Promise<Error | null>;
+    deleteFile(filePath: string): Promise<Error | null>;
+    exists(filePath: string): Promise<boolean>;
+    copyFile(source: string, destination: string): Promise<Error | null>;
+    moveFile(source: string, destination: string): Promise<Error | null>;
+    readDirectory(directoryPath: string): Promise<string[]>;
+    readDirectoryRecursive(directoryPath: string): Promise<string[]>;
+    readDirectoryFilePaths(directoryPath: string): Promise<string[] | Error>;
+    createEmptyDirectory(_directoryPath: string): Promise<Error | null>;
+    deleteDirectory(directoryPath: string): Promise<void>;
+    getFileSize(filePath: string): Promise<number | Error>;
+    getFileUpdatedTime(filePath: string): Promise<Date | Error>;
+    getFileCreatedTime(filePath: string): Promise<Date | Error>;
+    isDirectory(relativePath: string): Promise<boolean>;
+    isFile(relativePath: string): Promise<boolean>;
+    /**
+     * Get list of entries in directory
+     */
+    readDirectoryFileNames(directoryPath?: string): Promise<string[] | Error>;
+    /**
+     * Check if directory exists
+     */
+    directoryExists(relativePath: string): Promise<boolean>;
+    /**
+     * Check if file exists
+     */
+    fileExists(relativePath: string): Promise<boolean>;
+    /**
+     * Create directory if it doesn't exist
+     */
+    createDirectory(_relativePath: string): Promise<Error | null>;
+    /**
+     * Clear all files
+     */
+    clear(): void;
+    /**
+     * Check file existence (for testing)
+     */
+    hasFile(filePath: string): boolean;
+    /**
+     * Get file content (sync version, for testing)
+     */
+    getFileContent(filePath: string): string | undefined;
+    /**
+     * Get all file paths (for testing)
+     */
+    getAllFilePaths(): string[];
+    /**
+     * Get file count (for testing)
+     */
+    getFileCount(): number;
+    /**
+     * Setup test data
+     */
+    setupTestFiles(files: Record<string, string>): void;
+}
+
+export { DocFileSystemMock };

package/build/file-system-mock.js

@@ -0,0 +1,513 @@
+// lib/modules/path-system/doc-path-system.ts
+var DocPathSystem = class {
+  separator = "/";
+  /**
+   * Join paths
+   */
+  join(...paths) {
+    const parts = [];
+    for (const path of paths) {
+      if (path === "") continue;
+      const segments = path.split(this.separator).filter(Boolean);
+      parts.push(...segments);
+    }
+    if (parts.length === 0) {
+      return ".";
+    }
+    const isAbsolute = paths[0]?.startsWith(this.separator);
+    const joined = parts.join(this.separator);
+    return isAbsolute ? `${this.separator}${joined}` : joined;
+  }
+  /**
+   * Get filename with extension
+   */
+  basename(path, ext) {
+    const segments = path.split(this.separator);
+    const filename = segments[segments.length - 1] || "";
+    if (ext && filename.endsWith(ext)) {
+      return filename.slice(0, -ext.length);
+    }
+    return filename;
+  }
+  /**
+   * Get directory name
+   */
+  dirname(path) {
+    const segments = path.split(this.separator);
+    if (segments.length <= 1) {
+      return ".";
+    }
+    segments.pop();
+    const dir = segments.join(this.separator);
+    return dir || ".";
+  }
+  /**
+   * Get extension
+   */
+  extname(path) {
+    const basename = this.basename(path);
+    const lastDot = basename.lastIndexOf(".");
+    if (lastDot <= 0) {
+      return "";
+    }
+    return basename.slice(lastDot);
+  }
+  /**
+   * Calculate relative path
+   */
+  relative(from, to) {
+    const fromSegments = from.split(this.separator).filter(Boolean);
+    const toSegments = to.split(this.separator).filter(Boolean);
+    let commonLength = 0;
+    for (let i = 0; i < Math.min(fromSegments.length, toSegments.length); i++) {
+      if (fromSegments[i] === toSegments[i]) {
+        commonLength++;
+      } else {
+        break;
+      }
+    }
+    const upCount = fromSegments.length - commonLength;
+    const upSegments = Array(upCount).fill("..");
+    const downSegments = toSegments.slice(commonLength);
+    const segments = [...upSegments, ...downSegments];
+    return segments.length > 0 ? segments.join(this.separator) : ".";
+  }
+  /**
+   * Convert to absolute path
+   */
+  resolve(...paths) {
+    let resolved = "";
+    for (const path of paths) {
+      if (path.startsWith(this.separator)) {
+        resolved = path;
+      } else if (path !== "") {
+        resolved = resolved ? this.join(resolved, path) : path;
+      }
+    }
+    return resolved || ".";
+  }
+  /**
+   * Normalize path
+   */
+  normalize(path) {
+    const isAbsolute = path.startsWith(this.separator);
+    const segments = path.split(this.separator).filter(Boolean);
+    const normalized = [];
+    for (const segment of segments) {
+      if (segment === "..") {
+        if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+          normalized.pop();
+        } else if (!isAbsolute) {
+          normalized.push("..");
+        }
+      } else if (segment !== ".") {
+        normalized.push(segment);
+      }
+    }
+    if (normalized.length === 0) {
+      return isAbsolute ? this.separator : ".";
+    }
+    const result = normalized.join(this.separator);
+    return isAbsolute ? `${this.separator}${result}` : result;
+  }
+  /**
+   * Check if path is absolute
+   */
+  isAbsolute(path) {
+    return path.startsWith(this.separator);
+  }
+};
+
+// lib/modules/file-system/doc-file-system-mock.ts
+var mockDirectoryData = {
+  "docs/index.md": `---
+icon: \u{1F4DA}
+---
+
+# Documentation
+
+Welcome to the documentation!`,
+  "docs/guide/index.md": `---
+icon: \u{1F4D6}
+---
+
+# Guide
+
+This is a guide.`,
+  "docs/guide/getting-started.md": `# Getting Started
+
+Let's get started!`,
+  "docs/guide/advanced.md": `# Advanced
+
+Advanced topics here.`,
+  "docs/api/index.md": `---
+icon: \u{1F527}
+---
+
+# API
+
+API documentation.`,
+  "docs/api/reference.md": `# API Reference
+
+Complete API reference.`
+};
+var DocFileSystemMock = class _DocFileSystemMock {
+  files = /* @__PURE__ */ new Map();
+  pathSystem;
+  basePath;
+  constructor(props) {
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.basePath = props.basePath.endsWith("/") ? props.basePath.slice(0, -1) : props.basePath;
+    if (!props.skipDefaultFiles) {
+      this.setupTestFiles(mockDirectoryData);
+    }
+    Object.freeze(this);
+  }
+  /**
+   * PathSystem accessor (for testing)
+   */
+  getPathSystem() {
+    return this.pathSystem;
+  }
+  /**
+   * Get file name from path
+   */
+  readFileName(relativePath) {
+    return this.pathSystem.basename(relativePath);
+  }
+  /**
+   * Get file extension from path
+   */
+  readFileExtension(relativePath) {
+    return this.pathSystem.extname(relativePath);
+  }
+  /**
+   * Get directory path where the file exists
+   */
+  readFileDirectory(relativePath) {
+    return this.pathSystem.dirname(relativePath);
+  }
+  /**
+   * Get base path
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+  /**
+   * Convert relative path to absolute path
+   */
+  resolve(relativePath) {
+    return this.pathSystem.join(this.basePath, relativePath);
+  }
+  /**
+   * Normalize path using basePath
+   */
+  normalizePath(filePath) {
+    if (filePath.startsWith(this.basePath)) {
+      return filePath;
+    }
+    const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    return `${this.basePath}/${cleanPath}`;
+  }
+  /**
+   * Create instance (mock data is automatically loaded)
+   */
+  static create(basePath = "/test") {
+    return new _DocFileSystemMock({ basePath });
+  }
+  /**
+   * Factory method for testing
+   */
+  static createWithFiles(props) {
+    const basePath = props.basePath ?? "/test";
+    const fileSystem = new _DocFileSystemMock({
+      basePath,
+      skipDefaultFiles: true
+    });
+    if (props.fileContents) {
+      const now = /* @__PURE__ */ new Date();
+      for (const [path, content] of Object.entries(props.fileContents)) {
+        const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+        const normalizedPath = path.startsWith(basePath) ? path : `${basePath}/${cleanPath}`;
+        fileSystem.files.set(normalizedPath, {
+          content,
+          modifiedTime: now,
+          createdTime: now,
+          size: new TextEncoder().encode(content).length
+        });
+      }
+    }
+    return fileSystem;
+  }
+  async readFile(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      return file ? file.content : null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read file at ${filePath}`);
+    }
+  }
+  async writeFile(filePath, content) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const now = /* @__PURE__ */ new Date();
+      const existing = this.files.get(normalizedPath);
+      this.files.set(normalizedPath, {
+        content,
+        modifiedTime: now,
+        createdTime: existing?.createdTime ?? now,
+        size: new TextEncoder().encode(content).length
+      });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${filePath}`);
+    }
+  }
+  async deleteFile(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      this.files.delete(normalizedPath);
+      return null;
+    } catch (error) {
+      return new Error(`Failed to delete file at ${filePath}: ${error}`);
+    }
+  }
+  async exists(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    if (this.files.has(normalizedPath)) {
+      return true;
+    }
+    const dirPath = normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async copyFile(source, destination) {
+    try {
+      const normalizedSource = this.normalizePath(source);
+      const normalizedDest = this.normalizePath(destination);
+      const file = this.files.get(normalizedSource);
+      if (!file) {
+        return new Error(`Source file not found: ${normalizedSource}`);
+      }
+      this.files.set(normalizedDest, {
+        ...file,
+        createdTime: /* @__PURE__ */ new Date()
+      });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to copy file from ${source} to ${destination}`);
+    }
+  }
+  async moveFile(source, destination) {
+    try {
+      const normalizedSource = this.normalizePath(source);
+      const normalizedDest = this.normalizePath(destination);
+      const file = this.files.get(normalizedSource);
+      if (!file) {
+        return new Error(`Source file not found: ${normalizedSource}`);
+      }
+      this.files.set(normalizedDest, file);
+      this.files.delete(normalizedSource);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to move file from ${source} to ${destination}`);
+    }
+  }
+  async readDirectory(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const entries = /* @__PURE__ */ new Set();
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        const relativePath = path.slice(dirPath.length);
+        const firstSegment = relativePath.split("/")[0];
+        if (firstSegment) {
+          entries.add(firstSegment);
+        }
+      }
+    }
+    return Array.from(entries).sort();
+  }
+  async readDirectoryRecursive(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const files = [];
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        files.push(path);
+      }
+    }
+    return files.sort();
+  }
+  async readDirectoryFilePaths(directoryPath) {
+    try {
+      const normalizedDir = this.normalizePath(directoryPath);
+      const dirPath = normalizedDir.endsWith("/") ? normalizedDir : `${normalizedDir}/`;
+      const files = [];
+      for (const path of this.files.keys()) {
+        if (path.startsWith(dirPath) && !path.slice(dirPath.length).includes("/")) {
+          const relativePath = path.startsWith(`${this.basePath}/`) ? path.slice(this.basePath.length + 1) : path;
+          files.push(relativePath);
+        }
+      }
+      return files.sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory file paths at ${directoryPath}`);
+    }
+  }
+  async createEmptyDirectory(_directoryPath) {
+    return null;
+  }
+  async deleteDirectory(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        this.files.delete(path);
+      }
+    }
+  }
+  async getFileSize(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.size;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${filePath}`);
+    }
+  }
+  async getFileUpdatedTime(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.modifiedTime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file modified time at ${filePath}`);
+    }
+  }
+  async getFileCreatedTime(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.createdTime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file created time at ${filePath}`);
+    }
+  }
+  async isDirectory(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    const dirPath = normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isFile(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    return this.files.has(normalizedPath);
+  }
+  /**
+   * Get list of entries in directory
+   */
+  async readDirectoryFileNames(directoryPath = "") {
+    try {
+      const normalizedDir = directoryPath === "" ? this.basePath : this.normalizePath(directoryPath);
+      const dirPath = normalizedDir.endsWith("/") ? normalizedDir : `${normalizedDir}/`;
+      const entries = /* @__PURE__ */ new Set();
+      for (const path of this.files.keys()) {
+        if (path.startsWith(dirPath)) {
+          const relativePath = path.slice(dirPath.length);
+          const firstSegment = relativePath.split("/")[0];
+          if (firstSegment) {
+            entries.add(firstSegment);
+          }
+        }
+      }
+      return Array.from(entries).sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${directoryPath}`);
+    }
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.isDirectory(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.isFile(relativePath);
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async createDirectory(_relativePath) {
+    return null;
+  }
+  /**
+   * Clear all files
+   */
+  clear() {
+    this.files.clear();
+  }
+  /**
+   * Check file existence (for testing)
+   */
+  hasFile(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    return this.files.has(normalizedPath);
+  }
+  /**
+   * Get file content (sync version, for testing)
+   */
+  getFileContent(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    return this.files.get(normalizedPath)?.content;
+  }
+  /**
+   * Get all file paths (for testing)
+   */
+  getAllFilePaths() {
+    return Array.from(this.files.keys()).map((path) => {
+      return path.startsWith(`${this.basePath}/`) ? path.slice(this.basePath.length + 1) : path;
+    }).sort();
+  }
+  /**
+   * Get file count (for testing)
+   */
+  getFileCount() {
+    return this.files.size;
+  }
+  /**
+   * Setup test data
+   */
+  setupTestFiles(files) {
+    const now = /* @__PURE__ */ new Date();
+    for (const [path, content] of Object.entries(files)) {
+      const normalizedPath = this.normalizePath(path);
+      this.files.set(normalizedPath, {
+        content,
+        modifiedTime: now,
+        createdTime: now,
+        size: new TextEncoder().encode(content).length
+      });
+    }
+  }
+};
+
+export { DocFileSystemMock };

package/build/file-system-node.d.ts

@@ -0,0 +1,16 @@
+import { a as DocPathSystem } from './doc-file-system.interface-C5vpYrOL.js';
+import { D as DocFileSystem } from './doc-file-system-DEmPPJPE.js';
+export { DocFileSystemRead as DocFileSystemNodeRead, DocFileSystemWrite as DocFileSystemNodeWrite } from './file-system.js';
+
+type Props = {
+    basePath: string;
+    pathSystem?: DocPathSystem;
+};
+/**
+ * Node.js file system with separate read/write components
+ */
+declare class DocFileSystemNode extends DocFileSystem {
+    constructor(props: Props);
+}
+
+export { DocFileSystemNode };