suwayomi-material-you-webui/src/typings.d.ts

/*
 * Copyright (C) Contributors to the Suwayomi project
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

interface IExtension {
    name: string;
    pkgName: string;
    versionName: string;
    versionCode: number;
    lang: string;
    isNsfw: boolean;
    apkName: string;
    iconUrl: string;
    installed: boolean;
    hasUpdate: boolean;
    obsolete: boolean;
}

interface ISource {
    id: string;
    name: string;
    lang: string;
    iconUrl: string;
    supportsLatest: boolean;
    isConfigurable: boolean;
    isNsfw: boolean;
    displayName: string;
}

interface ISourceFilters {
    type: string;
    filter: ISourceFilter;
}

interface ISourceFilter {
    name: string;
    state: number | string | boolean | ISourceFilters[] | IState;
    values?: string[];
    displayValues?: string[];
    selected?: ISelected;
}

interface ISelected {
    displayname: string;
    value: string;
    _value: string;
}

interface IState {
    ascending: boolean;
    index: number;
}

interface IMetadataMigration {
    appKeyPrefix?: { oldPrefix: string; newPrefix: string };
    values?: {
        /**
         * In case the migration should only be applied to a specific metadata key.
         * Otherwise, all metadata keys will get migrated.
         */
        key?: string;
        oldValue: string;
        newValue: string;
    }[];
    keys?: { oldKey: string; newKey: string }[];
}

interface IMetadata<VALUES extends AllowedMetadataValueTypes = string> {
    [key: string]: VALUES;
}

interface IMetadataHolder<VALUES extends AllowedMetadataValueTypes = string> {
    meta?: IMetadata<VALUES>;
}

type AllowedMetadataValueTypes = string | boolean | number | undefined;

type MangaMetadataKeys = keyof IReaderSettings;

type AppMetadataKeys = MangaMetadataKeys;

type MetadataKeyValuePair = [AppMetadataKeys, AllowedMetadataValueTypes];

interface IMangaCard {
    id: number;
    title: string;
    genre: string[];
    thumbnailUrl: string;
    unreadCount?: number;
    downloadCount?: number;
    inLibrary?: boolean;
    meta?: IMetadata;
}

interface IManga {
    id: number;
    sourceId: string;

    url: string;
    title: string;
    thumbnailUrl: string;

    artist: string;
    author: string;
    description: string;
    genre: string[];
    status: string;

    inLibrary: boolean;
    source: ISource;

    meta: IMetadata;

    realUrl: string;
    freshData: boolean;
    unreadCount?: number;
    downloadCount?: number;

    age: number;
    chaptersAge: number;
}

interface IChapter {
    id: number;
    url: string;
    name: string;
    uploadDate: number;
    chapterNumber: number;
    scanlator: string;
    mangaId: number;
    read: boolean;
    bookmarked: boolean;
    lastPageRead: number;
    lastReadAt: number;
    index: number;
    fetchedAt: number;
    chapterCount: number;
    pageCount: number;
    downloaded: boolean;
    meta: IAppMetadata;
}

interface IMangaChapter {
    manga: IManga;
    chapter: IChapter;
}

interface IPartialChapter {
    pageCount: number;
    index: number;
    chapterCount: number;
    lastPageRead: number;
}

interface ICategory {
    id: number;
    order: number;
    name: string;
    default: boolean;
    meta: IAppMetadata;
}

interface INavbarOverride {
    status: boolean;
    value: any;
}

type ReaderType =
    | 'ContinuesVertical'
    | 'Webtoon'
    | 'SingleVertical'
    | 'SingleRTL'
    | 'SingleLTR'
    | 'DoubleVertical'
    | 'DoubleRTL'
    | 'DoubleLTR'
    | 'ContinuesHorizontalLTR'
    | 'ContinuesHorizontalRTL';

interface IReaderSettings {
    staticNav: boolean;
    showPageNumber: boolean;
    loadNextOnEnding: boolean;
    readerType: ReaderType;
}

interface IReaderPage {
    index: number;
    src: string;
}

interface IReaderProps {
    pages: Array<IReaderPage>;
    pageCount: number;
    setCurPage: React.Dispatch<React.SetStateAction<number>>;
    curPage: number;
    initialPage: number;
    settings: IReaderSettings;
    manga: IMangaCard | IManga;
    chapter: IChapter | IPartialChapter;
    nextChapter: () => void;
    prevChapter: () => void;
}

interface IAbout {
    name: string;
    version: string;
    revision: string;
    buildType: 'Stable' | 'Preview';
    buildTime: number;
    github: string;
    discord: string;
}

interface IDownloadChapter {
    chapterIndex: number;
    mangaId: number;
    state: 'Queued' | 'Downloading' | 'Finished' | 'Error';
    progress: number;
    chapter: IChapter;
    manga: IManga;
}

interface IQueue {
    status: 'Stopped' | 'Started';
    queue: IDownloadChapter[];
}

interface IUpdateStatus {
    running: boolean;
    statusMap: {
        COMPLETE?: IManga[];
        RUNNING?: IManga[];
        PENDING?: IManga[];
    };
}

interface PreferenceProps {
    key: string;
    title: string;
    summary: string;
    defaultValue: any;
    currentValue: any;
    defaultValueType: string;

    // intetnal props
    updateValue: any;
}

interface TwoStatePreferenceProps extends PreferenceProps {
    // intetnal props
    type: 'Switch' | 'Checkbox';
}

interface CheckBoxPreferenceProps extends PreferenceProps {}

interface SwitchPreferenceCompatProps extends PreferenceProps {}

interface ListPreferenceProps extends PreferenceProps {
    entries: string[];
    entryValues: string[];
}

interface MultiSelectListPreferenceProps extends PreferenceProps {
    entries: string[];
    entryValues: string[];
}

interface EditTextPreferenceProps extends PreferenceProps {
    dialogTitle: string;
    dialogMessage: string;
    text: string;
}

interface SourcePreferences {
    type: string;
    props: any;
}

interface NavbarItem {
    path: string;
    title: string;
    SelectedIconComponent: OverridableComponent<SvgIconTypeMap<{}, 'svg'>>;
    IconComponent: OverridableComponent<SvgIconTypeMap<{}, 'svg'>>;
    show: 'mobile' | 'desktop' | 'both';
}

interface PaginatedList<T> {
    page: T[];
    hasNextPage: boolean;
}

type NullAndUndefined<T> = T | null | undefined;

type ChapterSortMode = 'fetchedAt' | 'source';

interface ChapterListOptions {
    active: boolean;
    unread: NullAndUndefined<boolean>;
    downloaded: NullAndUndefined<boolean>;
    bookmarked: NullAndUndefined<boolean>;
    reverse: boolean;
    sortBy: ChapterSortMode;
    showChapterNumber: boolean;
}

type ChapterOptionsReducerAction =
    | { type: 'filter'; filterType: string; filterValue: NullAndUndefined<boolean> }
    | { type: 'sortBy'; sortBy: ChapterSortMode }
    | { type: 'sortReverse' }
    | { type: 'showChapterNumber' };

type LibrarySortMode = 'sortToRead' | 'sortAlph' | 'sortID';

enum GridLayout {
    Compact = 0,
    Comfortable = 1,
    List = 2,
}

interface LibraryOptions {
    // display options
    showDownloadBadge: boolean;
    showUnreadBadge: boolean;
    gridLayout: GridLayout;
    SourcegridLayout: GridLayout;

    // filter options
    downloaded: NullAndUndefined<boolean>;
    unread: NullAndUndefined<boolean>;
    sorts: NullAndUndefined<LibrarySortMode>;
    sortDesc: NullAndUndefined<boolean>;
}

interface BatchChaptersChange {
    delete?: boolean;
    isRead?: boolean;
    isBookmarked?: boolean;
    lastPageRead?: number;
}