@ukwhatn/wikidot 1.0.10 → 4.0.2

package/dist/shared/index-7dqqxq7x.js

@@ -0,0 +1,105 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/common/errors/base.ts
+class WikidotError extends Error {
+  name;
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class UnexpectedError extends WikidotError {
+}
+
+// src/common/errors/amc.ts
+class AMCError extends WikidotError {
+}
+
+class AMCHttpError extends AMCError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+
+class WikidotStatusError extends AMCError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+
+class ResponseDataError extends AMCError {
+}
+
+// src/common/errors/session.ts
+class SessionError extends WikidotError {
+}
+
+class SessionCreateError extends SessionError {
+}
+
+class LoginRequiredError extends SessionError {
+  constructor(message = "Login is required for this operation") {
+    super(message);
+  }
+}
+
+// src/common/errors/target.ts
+class NotFoundException extends WikidotError {
+}
+
+class TargetExistsError extends WikidotError {
+}
+
+class TargetError extends WikidotError {
+}
+
+class ForbiddenError extends WikidotError {
+}
+
+class NoElementError extends WikidotError {
+}
+// src/common/types/result.ts
+import { err, errAsync, ok, okAsync, ResultAsync } from "neverthrow";
+var wdOk = (value) => ok(value);
+var wdErr = (error) => err(error);
+var wdOkAsync = (value) => okAsync(value);
+var wdErrAsync = (error) => errAsync(error);
+var fromPromise = (promise, errorMapper) => ResultAsync.fromPromise(promise, errorMapper);
+var combineResults = (results) => ResultAsync.combine(results);
+export { __toESM, __legacyDecorateClassTS, __require, WikidotError, UnexpectedError, AMCError, AMCHttpError, WikidotStatusError, ResponseDataError, SessionError, SessionCreateError, LoginRequiredError, NotFoundException, TargetExistsError, TargetError, ForbiddenError, NoElementError, wdOk, wdErr, wdOkAsync, wdErrAsync, fromPromise, combineResults };
+
+//# debugId=A3764A26372D2C2364756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/common/errors/base.ts", "src/common/errors/amc.ts", "src/common/errors/session.ts", "src/common/errors/target.ts", "src/common/types/result.ts"],
  "sourcesContent": [
    "/**\n * Wikidotライブラリの基底エラークラス\n * 全てのカスタムエラーはこのクラスを継承する\n */\nexport abstract class WikidotError extends Error {\n  /** エラー名 */\n  public override readonly name: string;\n\n  /**\n   * @param message - エラーメッセージ\n   */\n  constructor(message: string) {\n    super(message);\n    this.name = this.constructor.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/**\n * 予期せぬエラー\n * 内部的な不整合やバグを表す\n */\nexport class UnexpectedError extends WikidotError {}\n",
    "import { WikidotError } from './base';\n\n/**\n * Ajax Module Connector関連の基底エラー\n */\nexport class AMCError extends WikidotError {}\n\n/**\n * HTTPステータスコードエラー\n * AMCへのリクエストがHTTPエラーで失敗した場合\n */\nexport class AMCHttpError extends AMCError {\n  /** HTTPステータスコード */\n  public readonly statusCode: number;\n\n  /**\n   * @param message - エラーメッセージ\n   * @param statusCode - HTTPステータスコード\n   */\n  constructor(message: string, statusCode: number) {\n    super(message);\n    this.statusCode = statusCode;\n  }\n}\n\n/**\n * Wikidotステータスコードエラー\n * AMCレスポンスのstatusがokでない場合\n */\nexport class WikidotStatusError extends AMCError {\n  /** Wikidotステータスコード文字列 */\n  public readonly statusCode: string;\n\n  /**\n   * @param message - エラーメッセージ\n   * @param statusCode - ステータスコード（例: 'not_ok', 'try_again'）\n   */\n  constructor(message: string, statusCode: string) {\n    super(message);\n    this.statusCode = statusCode;\n  }\n}\n\n/**\n * レスポンスデータエラー\n * レスポンスのパースに失敗した場合\n */\nexport class ResponseDataError extends AMCError {}\n",
    "import { WikidotError } from './base';\n\n/**\n * セッション関連の基底エラー\n */\nexport class SessionError extends WikidotError {}\n\n/**\n * セッション作成失敗エラー\n * ログイン試行が失敗した場合にスロー\n */\nexport class SessionCreateError extends SessionError {}\n\n/**\n * ログイン必須エラー\n * 認証が必要な操作を未ログイン状態で実行した場合にスロー\n */\nexport class LoginRequiredError extends SessionError {\n  constructor(message = 'Login is required for this operation') {\n    super(message);\n  }\n}\n",
    "import { WikidotError } from './base';\n\n/**\n * リソース未発見エラー\n * 要求されたリソースが存在しない場合\n */\nexport class NotFoundException extends WikidotError {}\n\n/**\n * リソース既存エラー\n * 作成しようとしたリソースが既に存在する場合\n */\nexport class TargetExistsError extends WikidotError {}\n\n/**\n * ターゲット状態エラー\n * リソースが操作不可能な状態の場合（ロック中など）\n */\nexport class TargetError extends WikidotError {}\n\n/**\n * アクセス拒否エラー\n * 権限不足で操作が拒否された場合\n */\nexport class ForbiddenError extends WikidotError {}\n\n/**\n * HTML要素未発見エラー\n * パース中に必要な要素が見つからない場合\n */\nexport class NoElementError extends WikidotError {}\n",
    "import { err, errAsync, ok, okAsync, type Result, ResultAsync } from 'neverthrow';\nimport type { WikidotError } from '../errors';\n\n/** 同期Result型エイリアス */\nexport type WikidotResult<T> = Result<T, WikidotError>;\n\n/** 非同期Result型エイリアス */\nexport type WikidotResultAsync<T> = ResultAsync<T, WikidotError>;\n\n/** 成功Resultを生成 */\nexport const wdOk = <T>(value: T): WikidotResult<T> => ok(value);\n\n/** エラーResultを生成 */\nexport const wdErr = <E extends WikidotError>(error: E): WikidotResult<never> => err(error);\n\n/** 成功ResultAsyncを生成 */\nexport const wdOkAsync = <T>(value: T): WikidotResultAsync<T> => okAsync(value);\n\n/** エラーResultAsyncを生成 */\nexport const wdErrAsync = <E extends WikidotError>(error: E): WikidotResultAsync<never> =>\n  errAsync(error);\n\n/** Promiseからの変換 */\nexport const fromPromise = <T>(\n  promise: Promise<T>,\n  errorMapper: (error: unknown) => WikidotError\n): WikidotResultAsync<T> => ResultAsync.fromPromise(promise, errorMapper);\n\n/** 複数ResultAsyncの結合 */\nexport const combineResults = <T>(results: WikidotResultAsync<T>[]): WikidotResultAsync<T[]> =>\n  ResultAsync.combine(results);\n"
  ],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,MAAe,qBAAqB,MAAM;AAAA,EAEtB;AAAA,EAKzB,WAAW,CAAC,SAAiB;AAAA,IAC3B,MAAM,OAAO;AAAA,IACb,KAAK,OAAO,KAAK,YAAY;AAAA,IAC7B,OAAO,eAAe,MAAM,WAAW,SAAS;AAAA;AAEpD;AAAA;AAMO,MAAM,wBAAwB,aAAa;AAAC;;;ACjB5C,MAAM,iBAAiB,aAAa;AAAC;AAAA;AAMrC,MAAM,qBAAqB,SAAS;AAAA,EAEzB;AAAA,EAMhB,WAAW,CAAC,SAAiB,YAAoB;AAAA,IAC/C,MAAM,OAAO;AAAA,IACb,KAAK,aAAa;AAAA;AAEtB;AAAA;AAMO,MAAM,2BAA2B,SAAS;AAAA,EAE/B;AAAA,EAMhB,WAAW,CAAC,SAAiB,YAAoB;AAAA,IAC/C,MAAM,OAAO;AAAA,IACb,KAAK,aAAa;AAAA;AAEtB;AAAA;AAMO,MAAM,0BAA0B,SAAS;AAAC;;;AC1C1C,MAAM,qBAAqB,aAAa;AAAC;AAAA;AAMzC,MAAM,2BAA2B,aAAa;AAAC;AAAA;AAM/C,MAAM,2BAA2B,aAAa;AAAA,EACnD,WAAW,CAAC,UAAU,wCAAwC;AAAA,IAC5D,MAAM,OAAO;AAAA;AAEjB;;;ACfO,MAAM,0BAA0B,aAAa;AAAC;AAAA;AAM9C,MAAM,0BAA0B,aAAa;AAAC;AAAA;AAM9C,MAAM,oBAAoB,aAAa;AAAC;AAAA;AAMxC,MAAM,uBAAuB,aAAa;AAAC;AAAA;AAM3C,MAAM,uBAAuB,aAAa;AAAC;;AC9BlD;AAUO,IAAM,OAAO,CAAI,UAA+B,GAAG,KAAK;AAGxD,IAAM,QAAQ,CAAyB,UAAmC,IAAI,KAAK;AAGnF,IAAM,YAAY,CAAI,UAAoC,QAAQ,KAAK;AAGvE,IAAM,aAAa,CAAyB,UACjD,SAAS,KAAK;AAGT,IAAM,cAAc,CACzB,SACA,gBAC0B,YAAY,YAAY,SAAS,WAAW;AAGjE,IAAM,iBAAiB,CAAI,YAChC,YAAY,QAAQ,OAAO;",
  "debugId": "A3764A26372D2C2364756E2164756E21",
  "names": []
}

package/dist/shared/index-f2eh3ykk.js

@@ -0,0 +1,172 @@
+import {
+  NoElementError,
+  UnexpectedError,
+  fromPromise
+} from "./index-7dqqxq7x.js";
+
+// src/module/page/page-revision.ts
+import * as cheerio from "cheerio";
+class PageRevision {
+  page;
+  id;
+  revNo;
+  createdBy;
+  createdAt;
+  comment;
+  _source = null;
+  _html = null;
+  constructor(data) {
+    this.page = data.page;
+    this.id = data.id;
+    this.revNo = data.revNo;
+    this.createdBy = data.createdBy;
+    this.createdAt = data.createdAt;
+    this.comment = data.comment;
+  }
+  isSourceAcquired() {
+    return this._source !== null;
+  }
+  isHtmlAcquired() {
+    return this._html !== null;
+  }
+  get source() {
+    return this._source;
+  }
+  set source(value) {
+    this._source = value;
+  }
+  get html() {
+    return this._html;
+  }
+  set html(value) {
+    this._html = value;
+  }
+  getSource() {
+    return fromPromise((async () => {
+      if (this._source) {
+        return this._source.wikiText;
+      }
+      const result = await this.page.site.amcRequest([
+        {
+          moduleName: "history/PageSourceModule",
+          revision_id: this.id
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response from PageSourceModule");
+      }
+      const html = String(response.body ?? "");
+      const $ = cheerio.load(html);
+      const sourceElem = $("div.page-source");
+      if (sourceElem.length === 0) {
+        throw new NoElementError("Source element not found");
+      }
+      const sourceText = sourceElem.text();
+      return sourceText;
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get revision source: ${String(error)}`);
+    });
+  }
+  getHtml() {
+    return fromPromise((async () => {
+      if (this._html) {
+        return this._html;
+      }
+      const result = await this.page.site.amcRequest([
+        {
+          moduleName: "history/PageVersionModule",
+          revision_id: this.id
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response from PageVersionModule");
+      }
+      const html = String(response.body ?? "");
+      const $ = cheerio.load(html);
+      const contentElem = $("#page-content");
+      if (contentElem.length === 0) {
+        this._html = html;
+        return html;
+      }
+      const contentHtml = contentElem.html() ?? "";
+      this._html = contentHtml;
+      return contentHtml;
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get revision HTML: ${String(error)}`);
+    });
+  }
+  toString() {
+    return `PageRevision(id=${this.id}, revNo=${this.revNo})`;
+  }
+}
+
+class PageRevisionCollection extends Array {
+  page;
+  constructor(page, revisions) {
+    super();
+    this.page = page;
+    if (revisions) {
+      this.push(...revisions);
+    }
+  }
+  findById(id) {
+    return this.find((revision) => revision.id === id);
+  }
+  getSources() {
+    return fromPromise((async () => {
+      const results = await Promise.all(this.map(async (revision) => {
+        const result = await revision.getSource();
+        if (result.isErr()) {
+          throw result.error;
+        }
+        return result.value;
+      }));
+      return results;
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get sources: ${String(error)}`);
+    });
+  }
+  getHtmls() {
+    return fromPromise((async () => {
+      const results = await Promise.all(this.map(async (revision) => {
+        const result = await revision.getHtml();
+        if (result.isErr()) {
+          throw result.error;
+        }
+        return result.value;
+      }));
+      return results;
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get HTMLs: ${String(error)}`);
+    });
+  }
+}
+export {
+  PageRevisionCollection,
+  PageRevision
+};
+
+export { PageRevision, PageRevisionCollection };
+
+//# debugId=2CCA5AB31F653C1264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/module/page/page-revision.ts"],
  "sourcesContent": [
    "import * as cheerio from 'cheerio';\nimport { NoElementError, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { AbstractUser } from '../user';\nimport type { Page } from './page';\nimport type { PageSource } from './page-source';\n\n/**\n * ページリビジョンデータ\n */\nexport interface PageRevisionData {\n  page: Page;\n  id: number;\n  revNo: number;\n  createdBy: AbstractUser;\n  createdAt: Date;\n  comment: string;\n}\n\n/**\n * ページのリビジョン（編集履歴のバージョン）\n */\nexport class PageRevision {\n  /** リビジョンが属するページ */\n  public readonly page: Page;\n\n  /** リビジョンID */\n  public readonly id: number;\n\n  /** リビジョン番号 */\n  public readonly revNo: number;\n\n  /** リビジョン作成者 */\n  public readonly createdBy: AbstractUser;\n\n  /** リビジョン作成日時 */\n  public readonly createdAt: Date;\n\n  /** 編集コメント */\n  public readonly comment: string;\n\n  /** ソースコード（内部キャッシュ） */\n  private _source: PageSource | null = null;\n\n  /** HTML表示（内部キャッシュ） */\n  private _html: string | null = null;\n\n  constructor(data: PageRevisionData) {\n    this.page = data.page;\n    this.id = data.id;\n    this.revNo = data.revNo;\n    this.createdBy = data.createdBy;\n    this.createdAt = data.createdAt;\n    this.comment = data.comment;\n  }\n\n  /**\n   * ソースコードが取得済みかどうか\n   */\n  isSourceAcquired(): boolean {\n    return this._source !== null;\n  }\n\n  /**\n   * HTML表示が取得済みかどうか\n   */\n  isHtmlAcquired(): boolean {\n    return this._html !== null;\n  }\n\n  /**\n   * ソースコード（キャッシュ済み）を取得\n   */\n  get source(): PageSource | null {\n    return this._source;\n  }\n\n  /**\n   * ソースコードを設定\n   */\n  set source(value: PageSource | null) {\n    this._source = value;\n  }\n\n  /**\n   * HTML表示（キャッシュ済み）を取得\n   */\n  get html(): string | null {\n    return this._html;\n  }\n\n  /**\n   * HTML表示を設定\n   */\n  set html(value: string | null) {\n    this._html = value;\n  }\n\n  /**\n   * リビジョンのソースを取得する（REV-001）\n   * @returns ソース文字列\n   */\n  getSource(): WikidotResultAsync<string> {\n    return fromPromise(\n      (async () => {\n        // キャッシュがあれば返す\n        if (this._source) {\n          return this._source.wikiText;\n        }\n\n        const result = await this.page.site.amcRequest([\n          {\n            moduleName: 'history/PageSourceModule',\n            revision_id: this.id,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          throw new NoElementError('Empty response from PageSourceModule');\n        }\n\n        const html = String(response.body ?? '');\n        const $ = cheerio.load(html);\n\n        // ソースコードは<div class=\"page-source\">内にある\n        const sourceElem = $('div.page-source');\n        if (sourceElem.length === 0) {\n          throw new NoElementError('Source element not found');\n        }\n\n        const sourceText = sourceElem.text();\n        return sourceText;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get revision source: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * リビジョンのHTMLを取得する（REV-002）\n   * @returns HTML文字列\n   */\n  getHtml(): WikidotResultAsync<string> {\n    return fromPromise(\n      (async () => {\n        // キャッシュがあれば返す\n        if (this._html) {\n          return this._html;\n        }\n\n        const result = await this.page.site.amcRequest([\n          {\n            moduleName: 'history/PageVersionModule',\n            revision_id: this.id,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          throw new NoElementError('Empty response from PageVersionModule');\n        }\n\n        const html = String(response.body ?? '');\n        const $ = cheerio.load(html);\n\n        // HTMLコンテンツは<div id=\"page-content\">内にある\n        const contentElem = $('#page-content');\n        if (contentElem.length === 0) {\n          // page-contentがない場合はbody全体を返す\n          this._html = html;\n          return html;\n        }\n\n        const contentHtml = contentElem.html() ?? '';\n        this._html = contentHtml;\n        return contentHtml;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get revision HTML: ${String(error)}`);\n      }\n    );\n  }\n\n  toString(): string {\n    return `PageRevision(id=${this.id}, revNo=${this.revNo})`;\n  }\n}\n\n/**\n * ページリビジョンコレクション\n */\nexport class PageRevisionCollection extends Array<PageRevision> {\n  public readonly page: Page | null;\n\n  constructor(page: Page | null, revisions?: PageRevision[]) {\n    super();\n    this.page = page;\n    if (revisions) {\n      this.push(...revisions);\n    }\n  }\n\n  /**\n   * IDで検索\n   * @param id - リビジョンID\n   * @returns リビジョン（存在しない場合はundefined）\n   */\n  findById(id: number): PageRevision | undefined {\n    return this.find((revision) => revision.id === id);\n  }\n\n  /**\n   * 全リビジョンのソースを一括取得する\n   * @returns ソース文字列の配列\n   */\n  getSources(): WikidotResultAsync<string[]> {\n    return fromPromise(\n      (async () => {\n        const results = await Promise.all(\n          this.map(async (revision) => {\n            const result = await revision.getSource();\n            if (result.isErr()) {\n              throw result.error;\n            }\n            return result.value;\n          })\n        );\n        return results;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get sources: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * 全リビジョンのHTMLを一括取得する\n   * @returns HTML文字列の配列\n   */\n  getHtmls(): WikidotResultAsync<string[]> {\n    return fromPromise(\n      (async () => {\n        const results = await Promise.all(\n          this.map(async (revision) => {\n            const result = await revision.getHtml();\n            if (result.isErr()) {\n              throw result.error;\n            }\n            return result.value;\n          })\n        );\n        return results;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get HTMLs: ${String(error)}`);\n      }\n    );\n  }\n}\n"
  ],
  "mappings": "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",
  "debugId": "2CCA5AB31F653C1264756E2164756E21",
  "names": []
}