@interactive-inc/docs-client 0.0.4 → 0.0.6

package/build/doc-directory-reference.js

@@ -0,0 +1,292 @@
+import { DocFileIndexReference } from "./doc-file-index-reference";
+import { DocFileMdReference } from "./doc-file-md-reference";
+import { DocFileUnknownReference } from "./doc-file-unknown-reference";
+import { DocFileIndexEntity } from "./entities/doc-file-index-entity";
+import { DocFileMdEntity } from "./entities/doc-file-md-entity";
+import { DocFileUnknownEntity } from "./entities/doc-file-unknown-entity";
+/**
+ * ディレクトリの参照
+ */
+export class DocDirectoryReference {
+    props;
+    pathSystem;
+    constructor(props) {
+        this.props = props;
+        this.pathSystem = props.pathSystem;
+        Object.freeze(this);
+    }
+    get fileSystem() {
+        return this.props.fileSystem;
+    }
+    get basePath() {
+        return this.fileSystem.getBasePath();
+    }
+    get relativePath() {
+        return this.props.path;
+    }
+    get absolutePath() {
+        return this.pathSystem.join(this.basePath, this.relativePath);
+    }
+    get indexFileName() {
+        return this.props.indexFileName;
+    }
+    get indexFilePath() {
+        return this.pathSystem.join(this.basePath, this.relativePath, this.props.indexFileName);
+    }
+    get archiveDirectoryName() {
+        return this.props.archiveDirectoryName;
+    }
+    async fileNames() {
+        const filePaths = await this.fileSystem.readDirectoryFilePaths(this.relativePath);
+        return filePaths
+            .map((p) => this.pathSystem.basename(p))
+            .filter((name) => name.includes("."));
+    }
+    async archivedFileNames() {
+        const archivePath = this.pathSystem.join(this.relativePath, this.archiveDirectoryName);
+        const filePaths = await this.fileSystem.readDirectoryFilePaths(archivePath);
+        return filePaths
+            .map((p) => this.pathSystem.basename(p))
+            .filter((name) => name.includes("."));
+    }
+    async *filesGenerator() {
+        const fileNames = await this.fileNames();
+        // 通常のファイルを処理
+        for (const fileName of fileNames) {
+            if (fileName === "index.md")
+                continue;
+            if (fileName.endsWith(".md")) {
+                yield new DocFileMdReference({
+                    path: this.pathSystem.join(this.relativePath, fileName),
+                    fileSystem: this.fileSystem,
+                    pathSystem: this.pathSystem,
+                });
+                continue;
+            }
+            yield new DocFileUnknownReference({
+                path: this.pathSystem.join(this.relativePath, fileName),
+                fileSystem: this.fileSystem,
+                pathSystem: this.pathSystem,
+            });
+        }
+        // アーカイブされたファイルを処理
+        const archivedFileNames = await this.archivedFileNames();
+        for (const fileName of archivedFileNames) {
+            if (fileName === "index.md")
+                continue;
+            if (fileName.endsWith(".md")) {
+                yield new DocFileMdReference({
+                    path: this.pathSystem.join(this.relativePath, this.archiveDirectoryName, fileName),
+                    fileSystem: this.fileSystem,
+                    pathSystem: this.pathSystem,
+                });
+                continue;
+            }
+            yield new DocFileUnknownReference({
+                path: this.pathSystem.join(this.relativePath, this.archiveDirectoryName, fileName),
+                fileSystem: this.fileSystem,
+                pathSystem: this.pathSystem,
+            });
+        }
+    }
+    async *mdFilesGenerator() {
+        const files = this.filesGenerator();
+        for await (const file of files) {
+            if (file instanceof DocFileMdReference) {
+                yield file;
+            }
+        }
+    }
+    async files() {
+        const files = [];
+        for await (const file of this.filesGenerator()) {
+            files.push(file);
+        }
+        return files;
+    }
+    async mdFiles() {
+        const files = [];
+        for await (const file of this.filesGenerator()) {
+            if (file instanceof DocFileUnknownReference)
+                continue;
+            files.push(file);
+        }
+        return files;
+    }
+    file(fileName) {
+        const filePath = this.pathSystem.join(this.relativePath, fileName);
+        if (fileName.endsWith(".md")) {
+            return new DocFileMdReference({
+                path: filePath,
+                fileSystem: this.fileSystem,
+                pathSystem: this.pathSystem,
+            });
+        }
+        return new DocFileUnknownReference({
+            path: filePath,
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+    mdFile(fileName) {
+        return new DocFileMdReference({
+            path: this.pathSystem.join(this.relativePath, fileName),
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+    async readFiles() {
+        const entities = [];
+        for await (const file of this.filesGenerator()) {
+            const entity = await file.read();
+            if (entity instanceof Error)
+                continue;
+            entities.push(entity);
+        }
+        return entities;
+    }
+    async readMdFiles() {
+        const entities = [];
+        for await (const file of this.filesGenerator()) {
+            const entity = await file.read();
+            if (entity instanceof Error)
+                continue;
+            if (entity instanceof DocFileUnknownEntity)
+                continue;
+            entities.push(entity);
+        }
+        return entities;
+    }
+    async readUnknownFiles() {
+        const entities = [];
+        for await (const file of this.filesGenerator()) {
+            const entity = await file.read();
+            if (entity instanceof Error)
+                continue;
+            if (entity instanceof DocFileMdEntity)
+                continue;
+            entities.push(entity);
+        }
+        return entities;
+    }
+    /**
+     * サブディレクトリ名の一覧を取得
+     */
+    async directoryNames() {
+        const allFileNames = await this.fileSystem.readDirectoryFileNames(this.relativePath);
+        const directoryNames = [];
+        for (const fileName of allFileNames) {
+            // アーカイブディレクトリは除外
+            if (fileName.startsWith(this.archiveDirectoryName))
+                continue;
+            const filePath = this.pathSystem.join(this.relativePath, fileName);
+            const isDirectory = await this.fileSystem.isDirectory(filePath);
+            if (isDirectory) {
+                directoryNames.push(fileName);
+            }
+        }
+        return directoryNames;
+    }
+    /**
+     * サブディレクトリの参照を取得
+     */
+    async directories() {
+        const directoryNames = await this.directoryNames();
+        return directoryNames.map((dirName) => {
+            const dirPath = this.pathSystem.join(this.relativePath, dirName);
+            return new DocDirectoryReference({
+                path: dirPath,
+                indexFileName: this.indexFileName,
+                archiveDirectoryName: this.archiveDirectoryName,
+                fileSystem: this.fileSystem,
+                pathSystem: this.pathSystem,
+            });
+        });
+    }
+    /**
+     * 単一のサブディレクトリ参照を取得
+     */
+    directory(directoryName) {
+        const dirPath = this.pathSystem.join(this.relativePath, directoryName);
+        return new DocDirectoryReference({
+            path: dirPath,
+            indexFileName: this.indexFileName,
+            archiveDirectoryName: this.archiveDirectoryName,
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+    indexFile() {
+        return new DocFileIndexReference({
+            path: this.pathSystem.join(this.relativePath, this.indexFileName),
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+    async readIndexFile() {
+        const ref = this.indexFile();
+        return ref.read();
+    }
+    async writeFile(entity) {
+        const filePath = this.pathSystem.join(this.relativePath, entity.value.path.nameWithExtension);
+        let content = null;
+        if (entity instanceof DocFileUnknownEntity) {
+            content = entity.value.content;
+        }
+        if (entity instanceof DocFileIndexEntity) {
+            content = entity.content.toText();
+        }
+        if (entity instanceof DocFileMdEntity) {
+            content = entity.content.toText();
+        }
+        if (content === null) {
+            return new Error("Entity content is undefined");
+        }
+        await this.fileSystem.writeFile(filePath, content);
+        return null;
+    }
+    async exists() {
+        return await this.fileSystem.exists(this.relativePath);
+    }
+    /**
+     * 一意なファイル名を生成する
+     */
+    async generateUniqueFileName(prefix = "document") {
+        const now = new Date();
+        const timestamp = now.toISOString().slice(0, 19).replace(/[:-]/g, "");
+        let counter = 0;
+        let fileName;
+        do {
+            const suffix = counter > 0 ? `-${counter}` : "";
+            fileName = `${prefix}-${timestamp}${suffix}.md`;
+            counter++;
+        } while (await this.fileExists(fileName));
+        return fileName;
+    }
+    /**
+     * 指定されたファイル名のファイルが存在するかチェック
+     */
+    async fileExists(fileName) {
+        const filePath = this.pathSystem.join(this.relativePath, fileName);
+        return await this.fileSystem.exists(filePath);
+    }
+    /**
+     * 新しいMarkdownファイルを作成する
+     */
+    async createMdFile(fileName) {
+        const actualFileName = fileName || (await this.generateUniqueFileName("document"));
+        // .mdが付いていない場合は追加
+        const mdFileName = actualFileName.endsWith(".md")
+            ? actualFileName
+            : `${actualFileName}.md`;
+        const filePath = this.pathSystem.join(this.relativePath, mdFileName);
+        const fileRef = new DocFileMdReference({
+            path: filePath,
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+        // デフォルトコンテンツでファイルを作成
+        await fileRef.writeDefault();
+        return fileRef;
+    }
+}

package/build/doc-directory-reference.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=doc-directory-reference.test.d.ts.map

package/build/doc-directory-reference.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-directory-reference.test.d.ts","sourceRoot":"","sources":["../lib/doc-directory-reference.test.ts"],"names":[],"mappings":""}

package/build/doc-directory-reference.test.js

@@ -0,0 +1,100 @@
+import { expect, test } from "bun:test";
+import { DocDirectoryReference } from "./doc-directory-reference";
+import { DocPathSystem } from "./doc-path-system";
+test("DocDirectoryReference - directoryNames メソッドでサブディレクトリ名を取得できる", async () => {
+    const mockFileSystem = {
+        getBasePath: () => "/test",
+        readDirectoryFileNames: async (path) => {
+            if (path === "docs") {
+                return ["file1.md", "subdir1", "subdir2", "_archive", "file2.txt"];
+            }
+            return [];
+        },
+        isDirectory: async (path) => {
+            return ["docs/subdir1", "docs/subdir2", "docs/_archive"].includes(path);
+        },
+    };
+    const pathSystem = new DocPathSystem();
+    const dirRef = new DocDirectoryReference({
+        path: "docs",
+        indexFileName: "index.md",
+        archiveDirectoryName: "_",
+        fileSystem: mockFileSystem,
+        pathSystem,
+    });
+    const dirNames = await dirRef.directoryNames();
+    expect(dirNames.length).toBe(2); // _archiveは除外
+    expect(dirNames).toContain("subdir1");
+    expect(dirNames).toContain("subdir2");
+    expect(dirNames).not.toContain("_archive");
+    expect(dirNames).not.toContain("file1.md");
+    expect(dirNames).not.toContain("file2.txt");
+});
+test("DocDirectoryReference - directories メソッドでサブディレクトリ参照を取得できる", async () => {
+    const mockFileSystem = {
+        getBasePath: () => "/test",
+        readDirectoryFileNames: async (path) => {
+            if (path === "docs") {
+                return ["subdir1", "subdir2", "_archive"];
+            }
+            return [];
+        },
+        isDirectory: async (path) => {
+            return ["docs/subdir1", "docs/subdir2", "docs/_archive"].includes(path);
+        },
+    };
+    const pathSystem = new DocPathSystem();
+    const dirRef = new DocDirectoryReference({
+        path: "docs",
+        indexFileName: "index.md",
+        archiveDirectoryName: "_",
+        fileSystem: mockFileSystem,
+        pathSystem,
+    });
+    const directories = await dirRef.directories();
+    expect(directories.length).toBe(2); // _archiveは除外
+    expect(directories[0]).toBeInstanceOf(DocDirectoryReference);
+    expect(directories[0].relativePath).toBe("docs/subdir1");
+    expect(directories[1].relativePath).toBe("docs/subdir2");
+});
+test("DocDirectoryReference - 空のディレクトリでも正常に動作する", async () => {
+    const mockFileSystem = {
+        getBasePath: () => "/test",
+        readDirectoryFileNames: async (_path) => {
+            return []; // 空のディレクトリ
+        },
+        isDirectory: async (_path) => {
+            return false;
+        },
+    };
+    const pathSystem = new DocPathSystem();
+    const dirRef = new DocDirectoryReference({
+        path: "empty",
+        indexFileName: "index.md",
+        archiveDirectoryName: "_",
+        fileSystem: mockFileSystem,
+        pathSystem,
+    });
+    const dirNames = await dirRef.directoryNames();
+    const directories = await dirRef.directories();
+    expect(dirNames.length).toBe(0);
+    expect(directories.length).toBe(0);
+});
+test("DocDirectoryReference - directory メソッドで単一のサブディレクトリ参照を取得できる", () => {
+    const mockFileSystem = {
+        getBasePath: () => "/test",
+    };
+    const pathSystem = new DocPathSystem();
+    const dirRef = new DocDirectoryReference({
+        path: "docs",
+        indexFileName: "index.md",
+        archiveDirectoryName: "_",
+        fileSystem: mockFileSystem,
+        pathSystem,
+    });
+    const subdir = dirRef.directory("guides");
+    expect(subdir).toBeInstanceOf(DocDirectoryReference);
+    expect(subdir.relativePath).toBe("docs/guides");
+    expect(subdir.indexFileName).toBe("index.md");
+    expect(subdir.archiveDirectoryName).toBe("_");
+});

package/build/doc-file-index-reference.d.ts

@@ -0,0 +1,72 @@
+import { DocFileRelationReference } from "./doc-file-relation-reference";
+import type { DocFileSystem } from "./doc-file-system";
+import type { DocPathSystem } from "./doc-path-system";
+import { DocFileIndexEntity } from "./entities/doc-file-index-entity";
+import type { DocRelationValue } from "./values/doc-relation-value";
+type Props = {
+    path: string;
+    fileSystem: DocFileSystem;
+    pathSystem: DocPathSystem;
+};
+/**
+ * ファイルを表すクラス
+ */
+export declare class DocFileIndexReference {
+    private readonly props;
+    private readonly pathSystem;
+    constructor(props: Props);
+    get fileSystem(): DocFileSystem;
+    get basePath(): string;
+    get filePath(): string;
+    get fileFullPath(): string;
+    get durectoryPath(): string;
+    read(): Promise<DocFileIndexEntity>;
+    /**
+     * ファイルの内容を読み込む
+     */
+    readContent(): Promise<Error | string>;
+    /**
+     * ファイルに内容を書き込む
+     */
+    writeContent(content: string): Promise<void>;
+    /**
+     * Entityを書き込む
+     */
+    write(entity: DocFileIndexEntity): Promise<void>;
+    /**
+     * 新しいファイルをデフォルトコンテンツで作成
+     */
+    writeDefault(): Promise<void>;
+    /**
+     * ファイルを削除
+     */
+    delete(): Promise<Error | null>;
+    /**
+     * ファイルが存在するか確認
+     */
+    exists(): Promise<boolean>;
+    relations(): Promise<DocFileRelationReference[]>;
+    readRelations(): Promise<DocRelationValue[]>;
+    /**
+     * ファイルのサイズを取得（バイト単位）
+     */
+    size(): Promise<number>;
+    /**
+     * ファイルの最終更新日時を取得
+     */
+    lastModified(): Promise<Date>;
+    /**
+     * ファイルの作成日時を取得
+     */
+    createdAt(): Promise<Date>;
+    /**
+     * ファイルをアーカイブに移動し、新しい参照を返す
+     */
+    archive(archiveDirectoryName?: string): Promise<DocFileIndexReference>;
+    /**
+     * ファイルをアーカイブから復元し、新しい参照を返す
+     */
+    restore(archiveDirectoryName?: string): Promise<DocFileIndexReference>;
+}
+export {};
+//# sourceMappingURL=doc-file-index-reference.d.ts.map

package/build/doc-file-index-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-file-index-reference.d.ts","sourceRoot":"","sources":["../lib/doc-file-index-reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAGrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,aAAa,CAAA;IACzB,UAAU,EAAE,aAAa,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,qBAAa,qBAAqB;IAGpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;IAE1C,YAA6B,KAAK,EAAE,KAAK,EAGxC;IAED,IAAI,UAAU,IAAI,aAAa,CAE9B;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAEK,IAAI,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAgCxC;IAED;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,CAM3C;IAED;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD;IAED;;OAEG;IACG,KAAK,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGrD;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CASlC;IAED;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAEpC;IAED;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAE/B;IAEK,SAAS,IAAI,OAAO,CAAC,wBAAwB,EAAE,CAAC,CA4BrD;IAEK,aAAa,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAYjD;IAED;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAE5B;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAElC;IAED;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/B;IAED;;OAEG;IACG,OAAO,CAAC,oBAAoB,SAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAkBxE;IAED;;OAEG;IACG,OAAO,CAAC,oBAAoB,SAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA0BxE;CACF"}

package/build/doc-file-index-reference.js

@@ -0,0 +1,191 @@
+import { DocFileRelationReference } from "./doc-file-relation-reference";
+import { DocFileIndexEntity } from "./entities/doc-file-index-entity";
+import { DocFileContentIndexValue } from "./values/doc-file-content-index-value";
+import { DocFilePathValue } from "./values/doc-file-path-value";
+/**
+ * ファイルを表すクラス
+ */
+export class DocFileIndexReference {
+    props;
+    pathSystem;
+    constructor(props) {
+        this.props = props;
+        this.pathSystem = props.pathSystem;
+        Object.freeze(this);
+    }
+    get fileSystem() {
+        return this.props.fileSystem;
+    }
+    get basePath() {
+        return this.fileSystem.getBasePath();
+    }
+    get filePath() {
+        return this.props.path;
+    }
+    get fileFullPath() {
+        return this.pathSystem.join(this.basePath, this.filePath);
+    }
+    get durectoryPath() {
+        return this.pathSystem.dirname(this.filePath);
+    }
+    async read() {
+        const content = await this.fileSystem.readFile(this.filePath);
+        if (content === null) {
+            const dirName = this.filePath.split("/").pop() || "directory";
+            const pathValue = DocFilePathValue.fromPathWithSystem(this.filePath, this.pathSystem, this.fileSystem.getBasePath());
+            const contentValue = DocFileContentIndexValue.empty(dirName);
+            return new DocFileIndexEntity({
+                type: "index",
+                path: pathValue.toJson(),
+                content: contentValue.toJson(),
+                isArchived: false,
+            });
+        }
+        const pathValue = DocFilePathValue.fromPathWithSystem(this.filePath, this.pathSystem, this.fileSystem.getBasePath());
+        const contentValue = DocFileContentIndexValue.fromMarkdown(content);
+        return new DocFileIndexEntity({
+            type: "index",
+            path: pathValue.toJson(),
+            content: contentValue.toJson(),
+            isArchived: false,
+        });
+    }
+    /**
+     * ファイルの内容を読み込む
+     */
+    async readContent() {
+        const entity = await this.read();
+        if (entity instanceof Error) {
+            return entity;
+        }
+        return entity.value.content.body;
+    }
+    /**
+     * ファイルに内容を書き込む
+     */
+    async writeContent(content) {
+        await this.fileSystem.writeFile(this.filePath, content);
+    }
+    /**
+     * Entityを書き込む
+     */
+    async write(entity) {
+        const content = entity.content.toText();
+        await this.fileSystem.writeFile(this.filePath, content);
+    }
+    /**
+     * 新しいファイルをデフォルトコンテンツで作成
+     */
+    async writeDefault() {
+        const dirPath = this.pathSystem.dirname(this.filePath);
+        const dirName = this.pathSystem.basename(dirPath) || "ディレクトリ";
+        const defaultContent = [
+            `# ${dirName}`,
+            "",
+            `${dirName}に関する概要をここに記載してください。`,
+        ].join("\n");
+        await this.fileSystem.writeFile(this.filePath, defaultContent);
+    }
+    /**
+     * ファイルを削除
+     */
+    async delete() {
+        return await this.fileSystem.deleteFile(this.filePath);
+    }
+    /**
+     * ファイルが存在するか確認
+     */
+    async exists() {
+        return this.fileSystem.exists(this.filePath);
+    }
+    async relations() {
+        const indexFile = await this.read();
+        if (indexFile instanceof Error) {
+            return [];
+        }
+        const schema = indexFile.content.frontMatter.value.schema;
+        if (!schema) {
+            return [];
+        }
+        const relationFields = Object.entries(schema).filter(([_key, field]) => {
+            return field.type === "relation" || field.type === "multi-relation";
+        });
+        return relationFields.map(([, field]) => {
+            if ((field.type === "relation" || field.type === "multi-relation") &&
+                field.path) {
+                return new DocFileRelationReference({
+                    filePath: field.path,
+                    fileSystem: this.fileSystem,
+                    pathSystem: this.pathSystem,
+                });
+            }
+            throw new Error("Unexpected field type or missing path");
+        });
+    }
+    async readRelations() {
+        const relations = await this.relations();
+        const files = [];
+        for (const relation of relations) {
+            const entity = await relation.read();
+            if (entity === null)
+                continue;
+            files.push(entity);
+        }
+        return files;
+    }
+    /**
+     * ファイルのサイズを取得（バイト単位）
+     */
+    async size() {
+        return this.fileSystem.getFileSize(this.filePath);
+    }
+    /**
+     * ファイルの最終更新日時を取得
+     */
+    async lastModified() {
+        return this.fileSystem.getFileModifiedTime(this.filePath);
+    }
+    /**
+     * ファイルの作成日時を取得
+     */
+    async createdAt() {
+        return this.fileSystem.getFileCreatedTime(this.filePath);
+    }
+    /**
+     * ファイルをアーカイブに移動し、新しい参照を返す
+     */
+    async archive(archiveDirectoryName = "_") {
+        const dirPath = this.pathSystem.dirname(this.filePath);
+        const fileName = this.pathSystem.basename(this.filePath);
+        const archivePath = this.pathSystem.join(dirPath, archiveDirectoryName, fileName);
+        // ファイルを移動
+        await this.fileSystem.moveFile(this.filePath, archivePath);
+        // 新しいパスで参照を作成
+        return new DocFileIndexReference({
+            path: archivePath,
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+    /**
+     * ファイルをアーカイブから復元し、新しい参照を返す
+     */
+    async restore(archiveDirectoryName = "_") {
+        const dirPath = this.pathSystem.dirname(this.filePath);
+        const parentDirName = this.pathSystem.basename(dirPath);
+        // 親ディレクトリがアーカイブディレクトリでない場合はエラー
+        if (parentDirName !== archiveDirectoryName) {
+            throw new Error(`ファイルはアーカイブディレクトリにありません: ${this.filePath}`);
+        }
+        const fileName = this.pathSystem.basename(this.filePath);
+        const restorePath = this.pathSystem.join(this.pathSystem.dirname(dirPath), fileName);
+        // ファイルを移動
+        await this.fileSystem.moveFile(this.filePath, restorePath);
+        // 新しいパスで参照を作成
+        return new DocFileIndexReference({
+            path: restorePath,
+            fileSystem: this.fileSystem,
+            pathSystem: this.pathSystem,
+        });
+    }
+}

package/build/doc-file-index-reference.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=doc-file-index-reference.test.d.ts.map

package/build/doc-file-index-reference.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-file-index-reference.test.d.ts","sourceRoot":"","sources":["../lib/doc-file-index-reference.test.ts"],"names":[],"mappings":""}