@delta-comic/model 0.0.0-semantically-released

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './struct';
+export * as uni from './model';

package/dist/lib/model/comment.d.ts

@@ -0,0 +1,49 @@
+import { default as dayjs } from 'dayjs';
+import { Component } from 'vue';
+import { Item } from './item';
+import { User } from './user';
+import { SourcedKeyMap, Struct, MetaData, RStream } from '../struct';
+export interface RawComment {
+    sender: User;
+    content: {
+        type: 'string' | 'html';
+        text: string;
+    };
+    time: number;
+    id: string;
+    childrenCount: number;
+    likeCount: number;
+    isLiked: boolean;
+    reported: boolean;
+    $$plugin: string;
+    $$meta?: MetaData;
+    isTop: boolean;
+}
+export type CommentRow = Component<{
+    comment: Comment;
+    item: Item;
+    parentComment?: Comment;
+}>;
+export 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;
+    get $time(): dayjs.Dayjs;
+    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 children: RStream<Comment>;
+}

package/dist/lib/model/content.d.ts

@@ -0,0 +1,48 @@
+import { AudioSrc, MediaSrc, TextTrackInit } from 'vidstack';
+import { Component } from 'vue';
+import { Image } from './image';
+import { SourcedKeyMap, RStream, SourcedKeyType } from '../struct';
+import * as comment from './comment';
+import * as ep from './ep';
+import * as item from './item';
+export type PreloadValue = item.Item | undefined;
+export type ContentPageLike = new (preload: PreloadValue, id: string, ep: string) => ContentPage;
+export type ContentType_ = SourcedKeyType<typeof ContentPage.contentPage>;
+export type ContentType = Exclude<ContentType_, string>;
+export type ViewComp = Component<{
+    page: ContentPage;
+    isFullScreen: boolean;
+}>;
+export type ViewLayoutComp = Component<{
+    page: ContentPage;
+}>;
+export declare abstract class ContentPage<T extends object = any> {
+    id: string;
+    ep: string;
+    static viewLayout: import('vue').ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ViewLayoutComp>>;
+    static contentPage: import('vue').ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ContentPageLike>>;
+    constructor(preload: PreloadValue, id: string, ep: string);
+    abstract contentType: ContentType;
+    pid: import('..').PromiseWithResolvers<string>;
+    preload: import('vue').ShallowRef<PreloadValue, PreloadValue>;
+    detail: import('..').PromiseWithResolvers<item.Item>;
+    union: import('vue').ComputedRef<PreloadValue>;
+    recommends: import('..').PromiseWithResolvers<item.Item[]>;
+    abstract comments: RStream<comment.Comment>;
+    eps: import('..').PromiseWithResolvers<ep.Ep[]>;
+    abstract loadAll(signal?: AbortSignal): Promise<any>;
+    abstract reloadAll(signal?: AbortSignal): Promise<any>;
+    abstract plugin: string;
+    abstract loadAllOffline(save: T): Promise<any>;
+    abstract exportOffline(): Promise<T>;
+    abstract ViewComp: ViewComp;
+}
+export declare abstract class ContentImagePage extends ContentPage {
+    images: import('..').PromiseWithResolvers<Image[]>;
+}
+export type VideoConfig = {
+    textTrack?: TextTrackInit[];
+} & Exclude<MediaSrc, string | AudioSrc>[];
+export declare abstract class ContentVideoPage extends ContentPage {
+    videos: import('..').PromiseWithResolvers<VideoConfig>;
+}

package/dist/lib/model/download.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class Downloader {
+    abstract id: string;
+    abstract name: string;
+    abstract $$plugin: string;
+    abstract begin: () => void;
+    abstract resume: () => void;
+    abstract pause: () => void;
+}

package/dist/lib/model/ep.d.ts

@@ -0,0 +1,14 @@
+import { Struct, MetaData } from '../struct';
+export interface RawEp {
+    name: string;
+    index: string;
+    $$plugin: string;
+    $$meta?: MetaData;
+}
+export declare class Ep extends Struct<RawEp> implements RawEp {
+    name: string;
+    index: string;
+    $$plugin: string;
+    $$meta?: MetaData;
+    constructor(v: RawEp);
+}

package/dist/lib/model/image.d.ts

@@ -0,0 +1,21 @@
+import { MetaData } from '../struct';
+import { Resource, RawResource, ProcessStep_ } from './resource';
+export interface RawImage {
+    $$plugin: string;
+    $$meta?: MetaData;
+    path: string;
+    forkNamespace: string;
+    processSteps?: ProcessStep_[];
+}
+export 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>;
+    set aspect(v: Partial<ImageAspect>);
+}
+export interface ImageAspect {
+    width: number;
+    height: number;
+}
+export type Image_ = string | Image;

package/dist/lib/model/index.d.ts

@@ -0,0 +1,8 @@
+export * as comment from './comment';
+export * as content from './content';
+export * as download from './download';
+export * as ep from './ep';
+export * as image from './image';
+export * as item from './item';
+export * as resource from './resource';
+export * as user from './user';

package/dist/lib/model/item.d.ts

@@ -0,0 +1,108 @@
+import { default as dayjs } from 'dayjs';
+import { Component } from 'vue';
+import { RawResource } from './resource';
+import { SourcedKeyMap, Struct, MetaData } from '../struct';
+import { ContentType, ContentType_ } from './content';
+import { Ep, RawEp } from './ep';
+import * as image from './image';
+export interface Category {
+    name: string;
+    group: string;
+    search: {
+        keyword: string;
+        source: string;
+        sort: string;
+    };
+}
+export interface Author {
+    label: string;
+    icon: RawResource | image.RawImage | string;
+    description: string;
+    /**
+     * 为空则不可订阅
+     * 否则传入的为`defineConfig`中定义的`subscribe.type`
+     */ subscribe?: string;
+    actions?: string[];
+    $$meta?: MetaData;
+    $$plugin: string;
+}
+export interface RawItem {
+    cover: RawResource | image.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;
+    $$plugin: string;
+    $$meta: MetaData;
+    description?: Description;
+    thisEp: RawEp;
+    commentSendable: boolean;
+    customIsSafe?: boolean;
+}
+export type ItemCardComp = 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;
+}>;
+export type ItemTranslator = (raw: RawItem) => Item;
+export type Description = string | {
+    type: 'html';
+    content: string;
+} | {
+    type: 'text';
+    content: string;
+};
+export 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 itemCard: import('vue').ShallowReactive<SourcedKeyMap<[plugin: string, name: string], ItemCardComp>>;
+    abstract like(signal?: AbortSignal): PromiseLike<boolean>;
+    abstract report(signal?: AbortSignal): PromiseLike<any>;
+    abstract sendComment(text: string, signal?: AbortSignal): PromiseLike<any>;
+    static is(value: unknown): value is Item;
+    cover: RawResource | image.RawImage;
+    get $cover(): image.Image;
+    title: string;
+    id: string;
+    categories: Category[];
+    author: Author[];
+    viewNumber?: number;
+    likeNumber?: number;
+    commentNumber?: number;
+    isLiked?: boolean;
+    description?: Description;
+    updateTime?: number;
+    get $updateTime(): dayjs.Dayjs;
+    contentType: ContentType;
+    length: string;
+    epLength: string;
+    $$plugin: string;
+    $$meta: MetaData;
+    thisEp: RawEp;
+    customIsSafe?: boolean;
+    get $thisEp(): Ep;
+    constructor(v: RawItem);
+    commentSendable: boolean;
+    customIsAI?: boolean;
+    get $isAi(): boolean;
+}

package/dist/lib/model/resource.d.ts

@@ -0,0 +1,36 @@
+import { SourcedKeyMap, Struct, MetaData } from '../struct';
+export type ProcessInstance = (nowPath: string, resource: Resource) => Promise<[path: string, exit: boolean]>;
+export interface ProcessStep {
+    referenceName: string;
+    ignoreExit?: boolean;
+}
+export type ProcessStep_ = ProcessStep | string;
+export interface ResourceType {
+    type: string;
+    urls: string[];
+    test: (url: string, signal: AbortSignal) => PromiseLike<void>;
+}
+export interface RawResource {
+    $$plugin: string;
+    $$meta?: MetaData;
+    pathname: string;
+    type: string;
+    processSteps?: ProcessStep_[];
+}
+export 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;
+}

package/dist/lib/model/user.d.ts

@@ -0,0 +1,23 @@
+import { Component } from 'vue';
+import { RawResource } from './resource';
+import { Image } from './image';
+export interface RawUser {
+    avatar?: RawResource;
+    name: string;
+    id: string;
+    $$plugin: string;
+}
+export declare abstract class User {
+    static userBase: import('vue').ShallowReactive<Map<string, User>>;
+    static userEditorBase: import('vue').ShallowReactive<Map<string, Component>>;
+    constructor(v: RawUser);
+    avatar?: Image;
+    name: string;
+    id: string;
+    $$plugin: string;
+    abstract customUser: object;
+}
+export type UserCardComp = Component<{
+    user: User;
+    isSmall?: boolean;
+}>;

package/dist/lib/struct/index.d.ts

@@ -0,0 +1,5 @@
+export type MetaData = Record<string | number, any>;
+export * from './promise';
+export * from './store';
+export * from './stream';
+export * from './struct';

package/dist/lib/struct/promise.d.ts

@@ -0,0 +1,49 @@
+import { Raw } from 'vue';
+type PromiseContentEmits<TR> = {
+    success: TR;
+    error: any;
+    finial: void;
+};
+/**
+ * 扩展内容的`Promise`，可视为普通`Promise`使用
+ */
+export declare class PromiseContent<T, TPF extends any = T, TEmits extends PromiseContentEmits<TPF> = PromiseContentEmits<TPF>> implements PromiseLike<T> {
+    private promise;
+    private processor;
+    [Symbol.toStringTag]: string;
+    private static _this;
+    static isPromiseContent(value: unknown): value is PromiseContent<any>;
+    static fromPromise<T, TP = T>(promise: Promise<T>, processor?: (val: T) => TP): RPromiseContent<T, TP>;
+    /**
+     * 使用`PromiseContent.fromPromise`或`PromiseContent.fromAsyncFunction`代替`new PromiseContent`
+     */
+    private constructor();
+    loadPromise(promise: Promise<T>): Promise<void>;
+    private emitter;
+    onError(processor: (err: TEmits['error']) => any): () => void;
+    onSuccess(processor: (err: TEmits['success']) => any): () => void;
+    onFinal(processor: (err: TEmits['finial']) => any): () => void;
+    /**
+     * 对`this.data.value`做出处理，多次调用仅最后一次生效
+     */
+    setProcessor<TP>(processor: (val: T) => TP): RPromiseContent<T, TP>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    data: import('vue').ShallowRef<TPF | undefined, TPF | undefined>;
+    isLoading: import('vue').ShallowRef<boolean, boolean>;
+    isError: import('vue').ShallowRef<boolean, boolean>;
+    errorCause: import('vue').ShallowRef<Error | undefined, Error | undefined>;
+    isEmpty: import('vue').ShallowRef<boolean, boolean>;
+    static fromAsyncFunction<T extends (...args: any[]) => Promise<any>>(asyncFunction: T): (...args: Parameters<T>) => RPromiseContent<Awaited<ReturnType<T>>>;
+    static resolve<T>(data: T): RPromiseContent<Awaited<T>, Awaited<T>>;
+    static withResolvers<T>(isLoading?: boolean): PromiseWithResolvers<T>;
+}
+export type PromiseWithResolvers<T> = {
+    content: RPromiseContent<T>;
+    reject: (reason?: any) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reset: (isLoading?: boolean) => void;
+};
+export type RPromiseContent<T, PTF = T> = Raw<PromiseContent<T, PTF>>;
+export {};

package/dist/lib/struct/store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 比如有很多需要注明来自哪个插件的值都可以用
+ */
+export 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);
+}
+export type SourcedKeyType<T extends SourcedKeyMap<[string, string], any> | SourcedValue<any>> = T extends SourcedKeyMap<[string, string], any> ? Parameters<T['get']>[0] : Parameters<T['toJSON']>[0];
+/**
+ * 相比较于普通的Map，这个元素的key操作可以是`TKey | string`
+ * _但内部保存仍使用`SourcedValue.toString`作为key_
+ */
+export declare class SourcedKeyMap<TKey extends [string, string], TValue> extends SourcedValue<TKey> implements Map<string, TValue> {
+    static create<TKey extends [string, string], TValue>(separator?: string): import('vue').ShallowReactive<SourcedKeyMap<TKey, TValue>>;
+    private constructor();
+    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]>;
+}

package/dist/lib/struct/stream.d.ts

@@ -0,0 +1,80 @@
+import { Raw, Ref } from 'vue';
+type RawGenerator<T> = (abortSignal: AbortSignal, that: Stream<T>) => IterableIterator<T[], void, Stream<T>> | AsyncIterableIterator<T[], void, Stream<T>>;
+/**
+ * _(网络)_ 数据流
+ */
+export type RStream<T> = Raw<Stream<T>>;
+/**
+ * 可迭代 _(网络)_ 数据流
+ */
+export declare class Stream<T> implements AsyncIterableIterator<T[], void> {
+    /**
+     * 使用`Stream.create`代替`new Stream`
+     */
+    private constructor();
+    private static _this;
+    static isStream(stream: any): stream is Stream<any>;
+    static create<T>(generator: RawGenerator<T>): RStream<T>;
+    [x: symbol]: any;
+    private abortController;
+    private generator;
+    private _setupData;
+    /** 初始存在的数据(置顶) */
+    setupData(data: T[]): this;
+    next(igRequesting?: boolean): Promise<IteratorResult<T[], void>>;
+    return(): Promise<IteratorResult<T[], void>>;
+    throw(e?: any): Promise<IteratorResult<T[], void>>;
+    /** 重置 */
+    reset(): void;
+    /** 重试 */
+    retry(): Promise<IteratorResult<T[], void>>;
+    /** 一次性全部加载 */
+    nextToDone(): Promise<T[]>;
+    /** 停止正在进行的请求 */
+    stop(): void;
+    [Symbol.asyncIterator](): this;
+    /** 错误(如果有) */
+    error: import('vue').ShallowRef<void | Error | undefined, void | Error | undefined>;
+    /** 数据 */
+    data: Ref<T[]>;
+    /** 数据 */
+    get _data(): T[];
+    /** 当前页 */
+    page: import('vue').ShallowRef<number, number>;
+    /** 当前页 */
+    get _page(): number;
+    /** 总页数 */
+    pages: import('vue').ShallowRef<number, number>;
+    /** 总页数 */
+    get _pages(): number;
+    /** 总条目数 */
+    total: import('vue').ShallowRef<number, number>;
+    /** 总条目数 */
+    get _total(): number;
+    /** 单页条目数 */
+    pageSize: import('vue').ShallowRef<number, number>;
+    /** 单页条目数 */
+    get _pageSize(): number;
+    /** 数据当前总数 */
+    length: import('vue').ComputedRef<number>;
+    /** 数据当前总数 */
+    get _length(): number;
+    /** 是否正在网络请求 */
+    isRequesting: import('vue').ShallowRef<boolean, boolean>;
+    /** 是否正在网络请求 */
+    get _isRequesting(): boolean;
+    /** 是否全部获取完成 */
+    isDone: import('vue').ShallowRef<boolean, boolean>;
+    /** 是否全部获取完成 */
+    get _isDone(): boolean;
+    /** 是否无结果 */
+    isNoData: import('vue').ComputedRef<boolean>;
+    /** 是否无结果 */
+    get _isNoData(): boolean;
+    /** 是否当前为空 */
+    isEmpty: import('vue').ComputedRef<boolean>;
+    /** 是否当前为空 */
+    get _isEmpty(): boolean;
+}
+export declare const callbackToPromise: <T = void>(fn: (resolve: (result: T | PromiseLike<T>) => void) => any) => Promise<T>;
+export {};

package/dist/lib/struct/struct.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 可以结构化的数据，调用`toJSON`获取纯粹的json(没有get/set或method)
+ */
+export 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;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@delta-comic/model",
+  "version": "0.0.0-semantically-released",
+  "description": "空阙虱楼",
+  "homepage": "https://github.com/delta-comic/delta-comic-core",
+  "license": "AGPL-3.0-only",
+  "author": {
+    "name": "wenxig",
+    "email": "wenxinguo12@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/delta-comic/delta-comic-core.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/lib/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@vueuse/core": "^14.2.1",
+    "dayjs": "^1.11.19",
+    "mitt": "^3.0.1",
+    "vidstack": "^1.12.13",
+    "@delta-comic/utils": "0.0.0-semantically-released",
+    "@delta-comic/request": "0.0.0-semantically-released"
+  },
+  "peerDependencies": {
+    "vue": "^3.5"
+  },
+  "release": {
+    "extends": "../../release.config.js",
+    "tagFormat": "model-${version}"
+  },
+  "dist": {
+    "tarball": "./dist/pack.tgz"
+  },
+  "readme": "./README.md",
+  "scripts": {
+    "build": "vite build && pnpm pack --out ./dist/pack.tgz"
+  }
+}