@interactive-inc/docs-client 1.0.20 → 1.1.1

package/build/file-system-json.js

@@ -0,0 +1,765 @@
+import { z } from 'zod';
+
+// lib/modules/file-system/doc-file-system-json.ts
+
+// 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.ts
+var DocFileSystem = class {
+  reader;
+  writer;
+  basePath;
+  pathSystem;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader;
+    this.writer = props.writer;
+  }
+  /**
+   * Read file content at the specified path
+   */
+  async readFile(relativePath) {
+    return this.reader.readFile(relativePath);
+  }
+  /**
+   * Write content to file at the specified path (creates directory if needed)
+   */
+  async writeFile(relativePath, content) {
+    return this.writer.writeFile(relativePath, content);
+  }
+  /**
+   * Delete file at the specified path
+   */
+  async deleteFile(relativePath) {
+    return this.writer.deleteFile(relativePath);
+  }
+  /**
+   * Get file name from path
+   */
+  readFileName(relativePath) {
+    return this.reader.readFileName(relativePath);
+  }
+  /**
+   * Get file extension from path
+   */
+  readFileExtension(relativePath) {
+    return this.reader.readFileExtension(relativePath);
+  }
+  /**
+   * Get directory path where the file exists
+   */
+  readFileDirectory(relativePath) {
+    return this.reader.readFileDirectory(relativePath);
+  }
+  /**
+   * Get list of entries in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    return this.reader.readDirectoryFileNames(relativePath);
+  }
+  async readDirectoryFilePaths(relativePath) {
+    return this.reader.readDirectoryFilePaths(relativePath);
+  }
+  /**
+   * Check if path is a directory
+   */
+  async isDirectory(relativePath) {
+    return this.reader.isDirectory(relativePath);
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(relativePath) {
+    return this.reader.isFile(relativePath);
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    return this.reader.exists(relativePath);
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.reader.directoryExists(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.reader.fileExists(relativePath);
+  }
+  /**
+   * Get base path
+   */
+  getBasePath() {
+    return this.reader.getBasePath();
+  }
+  /**
+   * Convert relative path to absolute path
+   */
+  resolve(relativePath) {
+    return this.reader.resolve(relativePath);
+  }
+  /**
+   * Create directory
+   */
+  async createEmptyDirectory(relativePath) {
+    return this.writer.createEmptyDirectory(relativePath);
+  }
+  /**
+   * Get file size in bytes
+   */
+  async getFileSize(relativePath) {
+    return this.reader.getFileSize(relativePath);
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async createDirectory(relativePath) {
+    return this.writer.createDirectory(relativePath);
+  }
+  /**
+   * Copy file
+   */
+  async copyFile(sourcePath, destinationPath) {
+    return this.writer.copyFile(sourcePath, destinationPath);
+  }
+  /**
+   * Move file
+   */
+  async moveFile(sourcePath, destinationPath) {
+    return this.writer.moveFile(sourcePath, destinationPath);
+  }
+  /**
+   * Get file last modified time
+   */
+  async getFileUpdatedTime(relativePath) {
+    return this.reader.getFileUpdatedTime(relativePath);
+  }
+  /**
+   * Get file creation time
+   */
+  async getFileCreatedTime(relativePath) {
+    return this.reader.getFileCreatedTime(relativePath);
+  }
+};
+var zJsonDocumentData = z.record(z.string(), z.string());
+function parseJsonDocumentData(data) {
+  try {
+    return zJsonDocumentData.parse(data);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("Failed to parse JSON document data");
+  }
+}
+var DocFileSystemJsonRead = class {
+  data;
+  basePath;
+  pathSystem;
+  constructor(props) {
+    const parsed = parseJsonDocumentData(props.data);
+    if (parsed instanceof Error) {
+      throw parsed;
+    }
+    this.data = parsed;
+    this.basePath = props.basePath ?? "docs";
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    Object.freeze(this);
+  }
+  /**
+   * Read file content from JSON data
+   */
+  async readFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      const content = this.data[normalizedPath];
+      return content ?? null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read file at ${relativePath}`);
+    }
+  }
+  /**
+   * 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 list of file names in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    try {
+      const normalizedDir = this.normalizePath(relativePath);
+      const fileNames = /* @__PURE__ */ new Set();
+      for (const filePath of Object.keys(this.data)) {
+        if (this.isFileInDirectory(filePath, normalizedDir)) {
+          const relativePart = this.getRelativePartFromDirectory(
+            filePath,
+            normalizedDir
+          );
+          const segments = relativePart.split("/").filter(Boolean);
+          if (segments.length > 0) {
+            fileNames.add(segments[0]);
+          }
+        }
+      }
+      return Array.from(fileNames).sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${relativePath}`);
+    }
+  }
+  /**
+   * Get list of file paths in directory
+   */
+  async readDirectoryFilePaths(relativePath) {
+    try {
+      const fileNames = await this.readDirectoryFileNames(relativePath);
+      if (fileNames instanceof Error) {
+        return fileNames;
+      }
+      return fileNames.map(
+        (fileName) => this.pathSystem.join(relativePath, fileName)
+      );
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory file paths at ${relativePath}`);
+    }
+  }
+  /**
+   * Check if path is a directory
+   */
+  async isDirectory(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      for (const filePath of Object.keys(this.data)) {
+        if (filePath.startsWith(`${normalizedPath}/`)) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      return normalizedPath in this.data;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    const isFile = await this.isFile(relativePath);
+    if (isFile) return true;
+    const isDir = await this.isDirectory(relativePath);
+    return isDir;
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.isDirectory(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.isFile(relativePath);
+  }
+  /**
+   * Get base path
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+  /**
+   * Convert relative path to absolute path
+   */
+  resolve(relativePath) {
+    return this.pathSystem.join(this.basePath, relativePath);
+  }
+  /**
+   * Get file size in bytes
+   */
+  async getFileSize(relativePath) {
+    try {
+      const content = await this.readFile(relativePath);
+      if (content instanceof Error) {
+        return content;
+      }
+      if (content === null) {
+        return new Error(`File not found: ${relativePath}`);
+      }
+      return Buffer.byteLength(content, "utf8");
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
+    }
+  }
+  /**
+   * Get file last modified time (not available for JSON data)
+   */
+  async getFileUpdatedTime(_relativePath) {
+    return new Error("File modified time not available for JSON data");
+  }
+  /**
+   * Get file creation time (not available for JSON data)
+   */
+  async getFileCreatedTime(_relativePath) {
+    return new Error("File creation time not available for JSON data");
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return Object.keys(this.data);
+  }
+  /**
+   * Get the raw JSON data
+   */
+  getRawData() {
+    return { ...this.data };
+  }
+  /**
+   * Normalize path by removing leading/trailing slashes
+   */
+  normalizePath(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+  }
+  /**
+   * Check if a file path is within a directory
+   */
+  isFileInDirectory(filePath, dirPath) {
+    if (dirPath === "") {
+      return true;
+    }
+    return filePath.startsWith(`${dirPath}/`) || filePath === dirPath;
+  }
+  /**
+   * Get the relative part of a file path from a directory
+   */
+  getRelativePartFromDirectory(filePath, dirPath) {
+    if (dirPath === "") {
+      return filePath;
+    }
+    if (filePath.startsWith(`${dirPath}/`)) {
+      return filePath.slice(dirPath.length + 1);
+    }
+    return "";
+  }
+};
+var zJsonDocumentData2 = z.record(z.string(), z.string());
+function parseJsonDocumentData2(data) {
+  try {
+    return zJsonDocumentData2.parse(data);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("Failed to parse JSON document data");
+  }
+}
+var DocFileSystemJsonWrite = class {
+  data;
+  basePath;
+  pathSystem;
+  reader;
+  onDataChange;
+  constructor(props = {}) {
+    if (props.data !== void 0) {
+      const parsed = parseJsonDocumentData2(props.data);
+      if (parsed instanceof Error) {
+        throw parsed;
+      }
+      this.data = parsed;
+    } else {
+      this.data = {};
+    }
+    this.basePath = props.basePath ?? "docs";
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader;
+    this.onDataChange = props.onDataChange;
+  }
+  /**
+   * Write content to JSON data
+   */
+  async writeFile(relativePath, content) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      this.data[normalizedPath] = content;
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${relativePath}`);
+    }
+  }
+  /**
+   * Delete file from JSON data
+   */
+  async deleteFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      if (!(normalizedPath in this.data)) {
+        return new Error(`File not found: ${relativePath}`);
+      }
+      delete this.data[normalizedPath];
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to delete file at ${relativePath}`);
+    }
+  }
+  /**
+   * Create directory (creates a placeholder entry)
+   */
+  async createEmptyDirectory(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      const gitkeepPath = this.pathSystem.join(normalizedPath, ".gitkeep");
+      const normalizedGitkeepPath = this.normalizePath(gitkeepPath);
+      this.data[normalizedGitkeepPath] = "";
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to create directory at ${relativePath}`);
+    }
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async createDirectory(relativePath) {
+    try {
+      if (this.reader) {
+        const exists = await this.reader.exists(relativePath);
+        if (exists) {
+          return null;
+        }
+      } else {
+        if (await this.directoryExistsInData(relativePath)) {
+          return null;
+        }
+      }
+      return await this.createEmptyDirectory(relativePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to ensure directory exists at ${relativePath}`);
+    }
+  }
+  /**
+   * Copy file within JSON data
+   */
+  async copyFile(sourcePath, destinationPath) {
+    try {
+      const normalizedSourcePath = this.normalizePath(sourcePath);
+      const normalizedDestPath = this.normalizePath(destinationPath);
+      if (this.reader) {
+        const content = await this.reader.readFile(sourcePath);
+        if (content instanceof Error) {
+          return content;
+        }
+        if (content === null) {
+          return new Error(`Source file not found: ${sourcePath}`);
+        }
+        this.data[normalizedDestPath] = content;
+      } else {
+        if (!(normalizedSourcePath in this.data)) {
+          return new Error(`Source file not found: ${sourcePath}`);
+        }
+        this.data[normalizedDestPath] = this.data[normalizedSourcePath];
+      }
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to copy file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Move file within JSON data
+   */
+  async moveFile(sourcePath, destinationPath) {
+    try {
+      const copyResult = await this.copyFile(sourcePath, destinationPath);
+      if (copyResult !== null) {
+        return copyResult;
+      }
+      return await this.deleteFile(sourcePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to move file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Get the current JSON data
+   */
+  getData() {
+    return { ...this.data };
+  }
+  /**
+   * Update the entire JSON data
+   */
+  setData(data) {
+    try {
+      const parsed = parseJsonDocumentData2(data);
+      if (parsed instanceof Error) {
+        return parsed;
+      }
+      this.data = parsed;
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error("Failed to set JSON data");
+    }
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.data = {};
+    this.notifyDataChange();
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return Object.keys(this.data);
+  }
+  /**
+   * Normalize path by removing leading/trailing slashes
+   */
+  normalizePath(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+  }
+  /**
+   * Check if directory exists in data
+   */
+  async directoryExistsInData(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    for (const filePath of Object.keys(this.data)) {
+      if (filePath.startsWith(`${normalizedPath}/`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Notify data change callback
+   */
+  notifyDataChange() {
+    if (this.onDataChange) {
+      this.onDataChange({ ...this.data });
+    }
+  }
+};
+
+// lib/modules/file-system/doc-file-system-json.ts
+z.record(z.string(), z.string());
+var DocFileSystemJson = class _DocFileSystemJson extends DocFileSystem {
+  jsonReader;
+  jsonWriter;
+  constructor(props = {}) {
+    const reader = new DocFileSystemJsonRead({
+      data: props.data,
+      basePath: props.basePath,
+      pathSystem: props.pathSystem
+    });
+    const writer = new DocFileSystemJsonWrite({
+      data: props.data,
+      basePath: props.basePath,
+      pathSystem: props.pathSystem,
+      reader,
+      onDataChange: props.onDataChange
+    });
+    super({
+      basePath: props.basePath ?? "docs",
+      pathSystem: props.pathSystem,
+      reader,
+      writer
+    });
+    this.jsonReader = reader;
+    this.jsonWriter = writer;
+    Object.freeze(this);
+  }
+  /**
+   * Get the current JSON data
+   */
+  getData() {
+    return this.jsonWriter.getData();
+  }
+  /**
+   * Update the entire JSON data
+   */
+  setData(data) {
+    return this.jsonWriter.setData(data);
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.jsonWriter.clear();
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return this.jsonReader.getAllFilePaths();
+  }
+  /**
+   * Get the raw JSON data (read-only copy)
+   */
+  getRawData() {
+    return this.jsonReader.getRawData();
+  }
+  /**
+   * Create from docs-to-json format
+   */
+  static fromDocsToJson(data, options = {}) {
+    return new _DocFileSystemJson({
+      ...options,
+      data
+    });
+  }
+  /**
+   * Export to docs-to-json format
+   */
+  toDocsToJson() {
+    return this.getData();
+  }
+};
+
+export { DocFileSystemJson, DocFileSystemJsonRead, DocFileSystemJsonWrite };