@delta-comic/model 2.2.0 → 3.0.0-next.4

package/dist/index.d.mts

@@ -0,0 +1,557 @@
+import { Component } from "vue";
+
+//#region lib/struct/store.d.ts
+/**
+ * 比如有很多需要注明来自哪个插件的值都可以用
+ */
+declare class SourcedValue<T extends [string, string]> {
+  separator: string;
+  toJSON(value: T | string): T;
+  parse(value: string): T;
+  toString(value: T | string): string;
+  stringify(value: T): string;
+  constructor(separator?: string);
+}
+/**
+ * 相比较于普通的Map，这个元素的key操作可以是`TKey | string`
+ * _但内部保存仍使用`SourcedValue.key.toString`作为key_
+ */
+declare class SourcedKeyMap<TKey extends [string, string], TValue> implements Map<string, TValue> {
+  getOrInsert(key: string | TKey, value: TValue): TValue;
+  getOrInsertComputed(key: string | TKey, compute: (key: string) => TValue): TValue;
+  static createReactive<TKey extends [string, string], TValue>(separator?: string): import("vue").ShallowReactive<SourcedKeyMap<TKey, TValue>>;
+  constructor(separator?: string);
+  key: SourcedValue<TKey>;
+  private store;
+  get size(): number;
+  [Symbol.toStringTag]: string;
+  clear(): void;
+  delete(key: string | TKey): boolean;
+  forEach(callbackfn: (value: TValue, key: string, map: Map<string, TValue>) => void, thisArg?: any): void;
+  get(key: string | TKey): TValue | undefined;
+  has(key: string | TKey): boolean;
+  set(key: string | TKey, value: TValue): this;
+  entries(): MapIterator<[string, TValue]>;
+  keys(): MapIterator<string>;
+  values(): MapIterator<TValue>;
+  [Symbol.iterator](): MapIterator<[string, TValue]>;
+}
+type SourcedKeyType<T extends SourcedKeyMap<[string, string], any> | SourcedValue<[string, string]>> = T extends SourcedKeyMap<infer K, any> ? K | string : T extends SourcedValue<infer K> ? K | string : never;
+//#endregion
+//#region lib/struct/struct.d.ts
+/**
+ * 可以结构化的数据，调用`toJSON`获取纯粹的json(没有get/set或method)
+ */
+declare class Struct<TRaw extends object> {
+  protected $$raw: TRaw;
+  toJSON(): TRaw;
+  /**
+   * @param $$raw 一个纯粹json对象，不可以是高级对象
+   */
+  constructor($$raw: TRaw);
+  static toRaw<T extends object, TRaw = (T extends Struct<infer TR> ? TR : T)>(item: T): TRaw;
+}
+//#endregion
+//#region lib/struct/meta.d.ts
+interface Metadatable {
+  $$meta?: Metadata;
+  $$plugin: string;
+}
+type Metadata = Record<string | number, any>;
+type PageKey = string | number;
+declare class StreamQuery<TResult, TData extends object = {}> {
+  query: (data: TData, page: PageKey, signal?: AbortSignal) => Promise<{
+    data: TResult[];
+    lastPage?: PageKey;
+    nextPage?: PageKey;
+  }>;
+  initPage: PageKey;
+  constructor(query: (data: TData, page: PageKey, signal?: AbortSignal) => Promise<{
+    data: TResult[];
+    lastPage?: PageKey;
+    nextPage?: PageKey;
+  }>, initPage: PageKey);
+}
+//#endregion
+//#region lib/struct/from.d.ts
+interface Base {
+  info: string;
+  placeholder?: string;
+  /**
+   * @default true
+   */
+  required?: boolean;
+}
+interface FormString extends Base {
+  type: 'string';
+  patten?: RegExp;
+  defaultValue?: FormDefaultValue['string'];
+}
+interface FormNumber extends Base {
+  type: 'number';
+  range?: [number, number];
+  float?: boolean;
+  defaultValue?: FormDefaultValue['number'];
+}
+interface FormRadio extends Base {
+  type: 'radio';
+  selects: {
+    label: string;
+    value: string;
+  }[];
+  comp: 'radio' | 'select';
+  defaultValue?: FormDefaultValue['radio'];
+}
+interface FormCheckbox extends Base {
+  type: 'checkbox';
+  selects: {
+    label: string;
+    value: string;
+  }[];
+  comp: 'checkbox' | 'multipleSelect';
+  defaultValue?: FormDefaultValue['checkbox'];
+}
+interface FormSwitch extends Base {
+  type: 'switch';
+  close?: string;
+  open?: string;
+  defaultValue?: FormDefaultValue['switch'];
+}
+interface FormDate extends Base {
+  type: 'date';
+  format: string;
+  time?: boolean;
+  defaultValue?: FormDefaultValue['date'];
+}
+interface FormDateRange extends Base {
+  type: 'dateRange';
+  format: string;
+  time?: boolean;
+  defaultValue?: FormDefaultValue['dateRange'];
+}
+interface FormPairs extends Base {
+  type: 'pairs';
+  defaultValue?: FormDefaultValue['pairs'];
+  noMultiple?: boolean;
+}
+interface FormDefaultValue {
+  string: string;
+  number: number;
+  radio: string;
+  checkbox: string[];
+  switch: boolean;
+  date: string;
+  pairs: {
+    key: string;
+    value: string;
+  }[];
+  dateRange: [Form: FormDefaultValue['date'], to: FormDefaultValue['date']];
+}
+type FormSingleConfigure = FormString | FormNumber | FormRadio | FormCheckbox | FormSwitch | FormDate | FormDateRange | FormPairs;
+type FormSingleResult<T extends FormSingleConfigure> = FormDefaultValue[T['type']];
+type FormConfigure = { [x in string]: FormSingleConfigure };
+type FormResult<T extends FormConfigure> = { [K in keyof T]: FormSingleResult<T[K]> };
+declare namespace download_d_exports {
+  export { ContentDownloadProvider, ContentDownloadSelection, DownloadAsset, DownloadChecksum, DownloadChecksumAlgorithm, DownloadPlan, DownloadSource, Downloader, HttpHeaderValue, HttpMirror, HttpSource, LegacyDownloader, RefreshSourceInput, RefreshSourceReason, ResolveDownloadInput, TorrentInput, TorrentSeedPolicy, TorrentSource };
+}
+type DownloadChecksumAlgorithm = 'sha256' | 'md5';
+interface DownloadChecksum {
+  algorithm: DownloadChecksumAlgorithm;
+  value: string;
+}
+/** A JSON-safe HTTP header value. Sensitive values should be passed by reference. */
+type HttpHeaderValue = {
+  type: 'value';
+  value: string;
+} | {
+  type: 'secretRef';
+  secretRef: string;
+};
+interface HttpMirror {
+  url: string;
+  /** Larger values are tried first. Mirrors with the same priority keep their declared order. */
+  priority?: number;
+  headers?: Record<string, HttpHeaderValue>;
+}
+interface HttpSource {
+  type: 'http';
+  mirrors: HttpMirror[];
+  etag?: string;
+  lastModified?: string;
+  expectedSize?: number;
+  /** Unix timestamp in milliseconds after which the source should be refreshed. */
+  expiresAt?: number;
+}
+type TorrentInput = {
+  type: 'magnet';
+  uri: string;
+} | {
+  type: 'url';
+  url: string;
+} | {
+  type: 'bytes';
+  base64: string;
+};
+type TorrentSeedPolicy = {
+  mode: 'none';
+} | {
+  mode: 'ratio';
+  ratio: number;
+} | {
+  mode: 'duration';
+  durationSeconds: number;
+} | {
+  mode: 'ratioOrDuration';
+  ratio: number;
+  durationSeconds: number;
+};
+interface TorrentSource {
+  type: 'torrent';
+  input: TorrentInput;
+  /** Zero-based file indexes in torrent metadata. Omit to download every file. */
+  onlyFiles?: number[];
+  seedPolicy?: TorrentSeedPolicy;
+}
+type DownloadSource = HttpSource | TorrentSource;
+/** A JSON-serializable file entry produced by a content plugin. */
+interface DownloadAsset {
+  /** Stable within the containing plan and across retries. */
+  key: string;
+  /** Relative to the destination selected by the host application. */
+  relativePath: string;
+  size?: number;
+  checksum?: DownloadChecksum;
+  source: DownloadSource;
+}
+/** A JSON-serializable group of files that should be enqueued together. */
+interface DownloadPlan {
+  /** Stable for the content represented by this plan. */
+  key: string;
+  title: string;
+  assets: DownloadAsset[];
+}
+type ContentDownloadSelection = {
+  type: 'currentEpisode';
+} | {
+  type: 'episodes';
+  episodeIds: string[];
+} | {
+  type: 'allEpisodes';
+};
+interface ResolveDownloadInput {
+  page: ContentPage;
+  selection: ContentDownloadSelection;
+}
+type RefreshSourceReason = 'expired' | 'unauthorized' | 'forbidden';
+interface RefreshSourceInput {
+  page: ContentPage;
+  planKey: string;
+  assetKey: string;
+  source: DownloadSource;
+  reason: RefreshSourceReason;
+}
+/**
+ * Resolves plugin-specific content into a portable download plan.
+ *
+ * Providers are runtime objects and are not serialized. Their returned plans and sources must be
+ * JSON-serializable so the native downloader can persist and resume them without a live WebView.
+ */
+interface ContentDownloadProvider {
+  resolve(input: ResolveDownloadInput, signal: AbortSignal): Promise<DownloadPlan>;
+  refreshSource?(input: RefreshSourceInput, signal: AbortSignal): Promise<DownloadSource>;
+}
+/**
+ * Legacy imperative download controller.
+ *
+ * @deprecated Register a {@link ContentDownloadProvider} for the content type and let the native
+ * downloader own task state, persistence, and lifecycle controls. This class remains unchanged so
+ * existing plugins can migrate without an immediate breaking change.
+ */
+declare abstract class Downloader implements Metadatable {
+  abstract id: string;
+  abstract name: string;
+  abstract $$plugin: string;
+  abstract $$meta?: Metadata;
+  abstract begin: () => void;
+  abstract resume: () => void;
+  abstract pause: () => void;
+}
+/** @deprecated Use {@link ContentDownloadProvider}. */
+type LegacyDownloader = Downloader;
+declare namespace ep_d_exports {
+  export { Ep, RawEp };
+}
+interface RawEp extends Metadatable {
+  name: string;
+  id: string;
+}
+declare class Ep extends Struct<RawEp> implements RawEp {
+  name: string;
+  id: string;
+  $$plugin: string;
+  $$meta?: Metadata;
+  constructor(v: RawEp);
+}
+declare namespace content_d_exports {
+  export { ContentPage, ContentPageLike, ContentType, ContentType_, LayoutComponent, ViewComponent };
+}
+type ContentPageLike = new (preload: Item | undefined, id: string, ep: string) => ContentPage;
+type ContentType_ = SourcedKeyType<typeof ContentPage.contentPages>;
+type ContentType = Exclude<ContentType_, string>;
+type ViewComponent = Component<{
+  page: ContentPage;
+  union?: Item;
+}>;
+type LayoutComponent = Component<{
+  page: ContentPage;
+}, any, any, any, any, any, {
+  view(args: {
+    item?: Item;
+  }): any;
+}>;
+declare abstract class ContentPage {
+  preload: Item | undefined;
+  id: string;
+  ep: string;
+  static layouts: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], LayoutComponent>>;
+  static contentPages: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ContentPageLike>>;
+  static downloadProviders: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ContentDownloadProvider>>;
+  constructor(preload: Item | undefined, id: string, ep: string);
+  abstract plugin: string;
+  abstract contentType: ContentType;
+  abstract fetchShortId(signal?: AbortSignal): Promise<string>;
+  abstract fetchDetail(signal?: AbortSignal): Promise<Item>;
+  abstract fetchRecommends: StreamQuery<Item>;
+  abstract fetchComments: StreamQuery<Comment>;
+  abstract fetchEps: StreamQuery<Ep>;
+  abstract ViewComponent: ViewComponent;
+}
+declare namespace resource_d_exports {
+  export { ProcessInstance, ProcessStep, ProcessStep_, RawResource, Resource, ResourceType };
+}
+type ProcessInstance = (nowPath: string, resource: Resource) => Promise<[path: string, exit: boolean]>;
+interface ProcessStep {
+  referenceName: string;
+  ignoreExit?: boolean;
+}
+type ProcessStep_ = ProcessStep | string;
+interface ResourceType {
+  type: string;
+  urls: string[];
+  test: (url: string, signal: AbortSignal) => PromiseLike<void>;
+}
+interface RawResource extends Metadatable {
+  pathname: string;
+  type: string;
+  processSteps?: ProcessStep_[];
+}
+declare class Resource extends Struct<RawResource> implements RawResource {
+  static processInstances: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, referenceName: string], ProcessInstance>>;
+  static fork: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, type: string], ResourceType>>;
+  static precedenceFork: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, type: string], string>>;
+  static is(value: unknown): value is Resource;
+  static create(v: RawResource): Resource;
+  protected constructor(v: RawResource);
+  type: string;
+  pathname: string;
+  processSteps: ProcessStep[];
+  $$meta?: Metadata;
+  $$plugin: string;
+  getUrl(): Promise<string>;
+  omittedForks: import("vue").ShallowReactive<Set<string>>;
+  getThisFork(): string;
+  localChangeFork(): boolean;
+}
+declare namespace image_d_exports {
+  export { Image, ImageAspect, Image_, RawImage };
+}
+interface RawImage extends Metadatable {
+  path: string;
+  forkNamespace: string;
+  processSteps?: ProcessStep_[];
+}
+declare class Image extends Resource {
+  static is(value: unknown): value is Image;
+  static create(v: RawResource | RawImage, aspect?: ImageAspect): Image;
+  protected constructor(v: RawResource | RawImage, aspect?: ImageAspect);
+  get aspect(): Partial<ImageAspect> | undefined;
+  set aspect(v: Partial<ImageAspect> | undefined);
+}
+interface ImageAspect {
+  width: number;
+  height: number;
+}
+type Image_ = string | Image;
+declare namespace item_d_exports {
+  export { Author, Category, Description, Item, ItemCardComponent, ItemTranslator, RawItem };
+}
+interface Category extends Metadatable {
+  name: string;
+  group: string;
+  search: {
+    keyword: string;
+    source: string;
+    sort: string;
+  };
+}
+interface Author extends Metadatable {
+  label: string;
+  icon: RawResource | RawImage | string;
+  description: string;
+  /**
+   * 为空则不可订阅
+   * 否则传入的为`defineConfig`中定义的`subscribe.type`
+   */
+  subscribe?: string;
+  actions?: string[];
+}
+interface RawItem extends Metadatable {
+  cover: RawResource | RawImage;
+  title: string;
+  id: string;
+  /** @alias tags  */
+  categories: Category[];
+  author: Author[];
+  viewNumber?: number;
+  likeNumber?: number;
+  commentNumber?: number;
+  isLiked?: boolean;
+  updateTime?: number;
+  customIsAI?: boolean;
+  contentType: ContentType_;
+  length: string;
+  epLength: string;
+  description?: Description;
+  thisEp: RawEp;
+  commentSendable: boolean;
+  customIsSafe?: boolean;
+}
+type ItemCardComponent = Component<{
+  item: Item;
+  freeHeight?: boolean;
+  disabled?: boolean;
+  type?: 'default' | 'big' | 'small';
+  class?: any;
+  style?: any;
+}, any, any, any, any, {
+  click: [];
+}, {
+  default(): void;
+  smallTopInfo(): void;
+  cover(): void;
+}>;
+type ItemTranslator = (raw: RawItem) => Item;
+type Description = string | {
+  type: 'html';
+  content: string;
+} | {
+  type: 'text';
+  content: string;
+};
+declare abstract class Item extends Struct<RawItem> implements RawItem {
+  static itemTranslator: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ItemTranslator>>;
+  static create(raw: RawItem): Item;
+  static authorIcon: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], Component>>;
+  static itemCards: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ItemCardComponent>>;
+  abstract like(): Promise<any>;
+  abstract report(): Promise<any>;
+  abstract sendComment(text: string): Promise<any>;
+  static is(value: unknown): value is Item;
+  cover: RawResource | RawImage;
+  get $cover(): Image;
+  title: string;
+  id: string;
+  categories: Category[];
+  author: Author[];
+  viewNumber?: number;
+  likeNumber?: number;
+  commentNumber?: number;
+  isLiked?: boolean;
+  description?: Description;
+  updateTime?: number;
+  contentType: ContentType;
+  length: string;
+  epLength: string;
+  $$plugin: string;
+  $$meta: Metadata | undefined;
+  thisEp: RawEp;
+  customIsSafe?: boolean;
+  get $thisEp(): Ep;
+  constructor(v: RawItem);
+  commentSendable: boolean;
+  customIsAI?: boolean;
+  get $isAi(): boolean;
+}
+declare namespace user_d_exports {
+  export { RawUser, User, UserCardComponent };
+}
+interface RawUser extends Metadatable {
+  avatar?: RawResource;
+  name: string;
+  id: string;
+}
+declare abstract class User {
+  static userBase: import("vue").ShallowReactive<Map<string, User>>;
+  static userEditorBase: import("vue").ShallowReactive<Map<string, Component>>;
+  static userCards: import("vue").ShallowReactive<Map<string, UserCardComponent>>;
+  constructor(v: RawUser);
+  avatar?: Image;
+  name: string;
+  id: string;
+  $$plugin: string;
+  $$meta?: Metadata;
+  abstract customUser: object;
+}
+type UserCardComponent = Component<{
+  user: User;
+  isSmall?: boolean;
+}>;
+declare namespace comment_d_exports {
+  export { Comment, CommentRow, RawComment };
+}
+interface RawComment extends Metadatable {
+  sender: User;
+  content: {
+    type: 'string' | 'html';
+    text: string;
+  };
+  time: number;
+  id: string;
+  childrenCount: number;
+  likeCount: number;
+  isLiked: boolean;
+  reported: boolean;
+  isTop: boolean;
+}
+type CommentRow = Component<{
+  comment: Comment;
+  item: Item;
+  parentComment?: Comment;
+}>;
+declare abstract class Comment extends Struct<RawComment> implements RawComment {
+  static commentRow: import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, name: string], CommentRow>>;
+  constructor(v: RawComment);
+  abstract sender: User;
+  content: {
+    type: 'string' | 'html';
+    text: string;
+  };
+  time: number;
+  id: string;
+  childrenCount: number;
+  likeCount: number;
+  isTop: boolean;
+  isLiked: boolean;
+  reported: boolean;
+  $$plugin: string;
+  $$meta?: Metadata;
+  abstract like(signal?: AbortSignal): PromiseLike<boolean>;
+  abstract report(signal?: AbortSignal): PromiseLike<any>;
+  abstract sendComment(text: string, signal?: AbortSignal): PromiseLike<any>;
+  abstract fetchChildren: StreamQuery<Comment>;
+}
+declare namespace index_d_exports {
+  export { comment_d_exports as comment, content_d_exports as content, download_d_exports as download, ep_d_exports as ep, image_d_exports as image, item_d_exports as item, resource_d_exports as resource, user_d_exports as user };
+}
+//#endregion
+export { Base, FormCheckbox, FormConfigure, FormDate, FormDateRange, FormDefaultValue, FormNumber, FormPairs, FormRadio, FormResult, FormSingleConfigure, FormSingleResult, FormString, FormSwitch, Metadata, Metadatable, PageKey, SourcedKeyMap, SourcedKeyType, SourcedValue, StreamQuery, Struct, index_d_exports as uni };