uview-plus 3.8.55 → 3.8.106

package/components/u-novel-reader/novelReader.js

@@ -0,0 +1,35 @@
+export default {
+    novelReader: {
+        chapters: [],
+        currentChapter: null,
+        loading: false,
+        error: null,
+        bookId: '',
+        storageKey: '',
+        persist: true,
+        initialProgress: null,
+        progress: null,
+        initialBookmarks: [],
+        bookmarks: null,
+        defaultSettings: {
+            theme: 'day',
+            fontSize: 18,
+            lineHeight: 1.8,
+            paragraphSpacing: 16,
+            contentWidth: '92%',
+            fontFamily: 'system',
+            fontWeight: 400,
+            animation: true
+        },
+        settings: null,
+        mode: 'scroll',
+        showBack: true,
+        autoBack: false,
+        backIcon: 'arrow-left',
+        safeAreaInsetTop: true,
+        safeAreaInsetBottom: true,
+        preloadThreshold: 2,
+        pageAnimation: true,
+        controlsAutoHide: 0
+    }
+}

package/components/u-novel-reader/persistence.js

@@ -0,0 +1,144 @@
+export const STORAGE_VERSION = 1
+export const DEFAULT_STORAGE_PREFIX = 'uview-plus:novel-reader:'
+
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function getStorageValue(key) {
+    if (!key || typeof uni === 'undefined' || typeof uni.getStorageSync !== 'function') {
+        return null
+    }
+    return uni.getStorageSync(key)
+}
+
+function normalizeProgress(value) {
+    if (value == null) return null
+    if (!isObject(value)) return null
+    const numericFields = ['chapterIndex', 'pageIndex', 'pageCount', 'charOffset', 'scrollTop']
+    for (const field of numericFields) {
+        if (value[field] !== undefined && (
+            !Number.isFinite(Number(value[field])) ||
+            Number(value[field]) < 0
+        )) {
+            return null
+        }
+    }
+    for (const field of ['chapterProgress', 'totalProgress']) {
+        if (value[field] !== undefined && (
+            !Number.isFinite(Number(value[field])) ||
+            Number(value[field]) < 0 ||
+            Number(value[field]) > 1
+        )) {
+            return null
+        }
+    }
+    return {
+        ...value,
+        pageIndex: Math.max(0, Number(value.pageIndex) || 0),
+        pageCount: Math.max(0, Number(value.pageCount) || 0),
+        charOffset: Math.max(0, Number(value.charOffset) || 0),
+        scrollTop: Math.max(0, Number(value.scrollTop) || 0)
+    }
+}
+
+function normalizeSettings(value) {
+    if (!isObject(value)) return {}
+    return { ...value }
+}
+
+function normalizeBookmarks(value) {
+    if (!Array.isArray(value)) return []
+    return value.filter((bookmark) => (
+        isObject(bookmark) &&
+        bookmark.id != null &&
+        bookmark.chapterId != null &&
+        Number.isFinite(Number(bookmark.charOffset)) &&
+        Number(bookmark.charOffset) >= 0
+    ))
+}
+
+export function createStorageKey({ storageKey = '', bookId = '' } = {}) {
+    if (storageKey) return String(storageKey)
+    if (bookId === '' || bookId == null) return ''
+    return `${DEFAULT_STORAGE_PREFIX}${bookId}`
+}
+
+export function normalizePersistedState(value) {
+    if (!isObject(value) || value.version !== STORAGE_VERSION) return null
+    const progress = normalizeProgress(value.progress)
+    const readingTime = Number(value.readingTime)
+    const updatedAt = Number(value.updatedAt)
+    if (
+        !Number.isFinite(readingTime) ||
+        readingTime < 0 ||
+        !Number.isFinite(updatedAt) ||
+        updatedAt < 0
+    ) {
+        return null
+    }
+    return {
+        version: STORAGE_VERSION,
+        progress,
+        settings: normalizeSettings(value.settings),
+        bookmarks: normalizeBookmarks(value.bookmarks),
+        readingTime,
+        updatedAt
+    }
+}
+
+export function readPersistedState(key) {
+    if (!key) return null
+    try {
+        const value = getStorageValue(key)
+        const parsed = typeof value === 'string' ? JSON.parse(value) : value
+        const normalized = normalizePersistedState(parsed)
+        if (
+            parsed != null &&
+            normalized == null &&
+            typeof uni !== 'undefined' &&
+            typeof uni.removeStorageSync === 'function'
+        ) {
+            uni.removeStorageSync(key)
+        }
+        return normalized
+    } catch (error) {
+        try {
+            if (typeof uni !== 'undefined' && typeof uni.removeStorageSync === 'function') {
+                uni.removeStorageSync(key)
+            }
+        } catch (removeError) {
+            return null
+        }
+        return null
+    }
+}
+
+export function writePersistedState(key, state) {
+    if (!key || typeof uni === 'undefined' || typeof uni.setStorageSync !== 'function') {
+        return false
+    }
+    const payload = {
+        version: STORAGE_VERSION,
+        progress: isObject(state && state.progress) ? state.progress : null,
+        settings: isObject(state && state.settings) ? state.settings : {},
+        bookmarks: Array.isArray(state && state.bookmarks) ? state.bookmarks : [],
+        readingTime: Math.max(0, Number(state && state.readingTime) || 0),
+        updatedAt: Date.now()
+    }
+    try {
+        uni.setStorageSync(key, payload)
+        return true
+    } catch (error) {
+        return false
+    }
+}
+
+export default {
+    STORAGE_VERSION,
+    DEFAULT_STORAGE_PREFIX,
+    createStorageKey,
+    normalizePersistedState,
+    readPersistedState,
+    writePersistedState
+}

package/components/u-novel-reader/props.js

@@ -0,0 +1,100 @@
+import { defineMixin } from '../../libs/vue'
+import { registerComponentProps } from '../../libs/config/props.js'
+import NovelReaderDefaultProps from './novelReader'
+
+const defProps = registerComponentProps(NovelReaderDefaultProps)
+
+export const props = defineMixin({
+    props: {
+        chapters: {
+            type: Array,
+            default: () => defProps.novelReader.chapters
+        },
+        currentChapter: {
+            type: Object,
+            default: () => defProps.novelReader.currentChapter
+        },
+        loading: {
+            type: Boolean,
+            default: () => defProps.novelReader.loading
+        },
+        error: {
+            type: Object,
+            default: () => defProps.novelReader.error
+        },
+        bookId: {
+            type: [String, Number],
+            default: () => defProps.novelReader.bookId
+        },
+        storageKey: {
+            type: String,
+            default: () => defProps.novelReader.storageKey
+        },
+        persist: {
+            type: Boolean,
+            default: () => defProps.novelReader.persist
+        },
+        initialProgress: {
+            type: Object,
+            default: () => defProps.novelReader.initialProgress
+        },
+        progress: {
+            type: Object,
+            default: () => defProps.novelReader.progress
+        },
+        initialBookmarks: {
+            type: Array,
+            default: () => defProps.novelReader.initialBookmarks
+        },
+        bookmarks: {
+            type: Array,
+            default: () => defProps.novelReader.bookmarks
+        },
+        defaultSettings: {
+            type: Object,
+            default: () => ({ ...defProps.novelReader.defaultSettings })
+        },
+        settings: {
+            type: Object,
+            default: () => defProps.novelReader.settings
+        },
+        mode: {
+            type: String,
+            default: () => defProps.novelReader.mode
+        },
+        showBack: {
+            type: Boolean,
+            default: () => defProps.novelReader.showBack
+        },
+        autoBack: {
+            type: Boolean,
+            default: () => defProps.novelReader.autoBack
+        },
+        backIcon: {
+            type: String,
+            default: () => defProps.novelReader.backIcon
+        },
+        safeAreaInsetTop: {
+            type: Boolean,
+            default: () => defProps.novelReader.safeAreaInsetTop
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            default: () => defProps.novelReader.safeAreaInsetBottom
+        },
+        preloadThreshold: {
+            type: Number,
+            default: () => defProps.novelReader.preloadThreshold
+        },
+        pageAnimation: {
+            type: Boolean,
+            default: () => defProps.novelReader.pageAnimation
+        },
+        controlsAutoHide: {
+            type: Number,
+            default: () => defProps.novelReader.controlsAutoHide
+        }
+    }
+})
+
+export default props

package/components/u-novel-reader/reader-catalog.vue

@@ -0,0 +1,234 @@
+<template>
+    <view class="up-novel-reader__catalog" :style="catalogStyle">
+            <view class="up-novel-reader__catalog-header">
+                <text class="up-novel-reader__catalog-title">目录</text>
+                <text class="up-novel-reader__catalog-count">{{ chapters.length }} 章</text>
+            </view>
+            <slot v-if="$slots.default"></slot>
+            <scroll-view v-else class="up-novel-reader__catalog-scroll" scroll-y>
+                <view
+                    v-for="chapter in chapters"
+                    :key="chapter.id || chapter.index"
+                    class="up-novel-reader__catalog-item"
+                    :class="{
+                        'is-current': isCurrent(chapter),
+                        'is-locked': chapter.isLocked
+                    }"
+                    :aria-disabled="chapter.isLocked ? 'true' : 'false'"
+                    @tap="selectChapter(chapter)"
+                >
+                    <view class="up-novel-reader__catalog-index">
+                        <u-icon
+                            v-if="chapter.isLocked"
+                            name="lock"
+                            size="14"
+                            :color="mutedColor"
+                        ></u-icon>
+                        <text v-else>{{ displayIndex(chapter) }}</text>
+                    </view>
+                    <text class="up-novel-reader__catalog-item-title">{{ chapter.title || `第${displayIndex(chapter)}章` }}</text>
+                    <u-icon
+                        v-if="isCurrent(chapter)"
+                        name="checkmark"
+                        size="16"
+                        :color="activeColor"
+                    ></u-icon>
+                </view>
+                <view v-if="!chapters.length" class="up-novel-reader__catalog-empty">暂无目录</view>
+                <view v-if="bookmarks.length" class="up-novel-reader__bookmark-section">
+                    <view class="up-novel-reader__bookmark-heading">
+                        <u-icon name="bookmark" size="15" :color="activeColor"></u-icon>
+                        <text>书签</text>
+                    </view>
+                    <view
+                        v-for="bookmark in bookmarks"
+                        :key="bookmark.id"
+                        class="up-novel-reader__bookmark-item"
+                        @tap="selectBookmark(bookmark)"
+                    >
+                        <text class="up-novel-reader__bookmark-excerpt">{{ bookmark.excerpt || '书签位置' }}</text>
+                        <text class="up-novel-reader__bookmark-progress">{{ bookmark.chapterIndex + 1 }} 章</text>
+                    </view>
+                </view>
+            </scroll-view>
+    </view>
+</template>
+
+<script>
+    export default {
+        name: 'NovelReaderCatalog',
+        props: {
+            chapters: {
+                type: Array,
+                default: () => []
+            },
+            currentChapter: {
+                type: Object,
+                default: null
+            },
+            bookmarks: {
+                type: Array,
+                default: () => []
+            },
+            progress: {
+                type: Object,
+                default: () => ({})
+            },
+            themeTokens: {
+                type: Object,
+                default: () => ({})
+            },
+        },
+        emits: ['chapter-select', 'bookmark-select'],
+        computed: {
+            catalogStyle() {
+                return {
+                    color: this.themeTokens.text || '#303133',
+                    backgroundColor: this.themeTokens.background || '#ffffff'
+                }
+            },
+            activeColor() {
+                return this.themeTokens.active || '#2979ff'
+            },
+            mutedColor() {
+                return this.themeTokens.muted || '#909399'
+            }
+        },
+        methods: {
+            displayIndex(chapter) {
+                const index = Number(chapter && chapter.index)
+                return Number.isFinite(index) ? index + 1 : ''
+            },
+            isCurrent(chapter) {
+                return Boolean(
+                    chapter &&
+                    this.currentChapter &&
+                    chapter.id === this.currentChapter.id
+                )
+            },
+            selectChapter(chapter) {
+                if (!chapter || chapter.isLocked) return
+                this.$emit('chapter-select', chapter)
+            },
+            selectBookmark(bookmark) {
+                if (!bookmark) return
+                this.$emit('bookmark-select', bookmark)
+            }
+        }
+    }
+</script>
+
+<style lang="scss" scoped>
+    .up-novel-reader__catalog {
+        display: flex;
+        flex-direction: column;
+        width: 82vw;
+        max-width: 360px;
+        height: 100%;
+        box-sizing: border-box;
+    }
+
+    .up-novel-reader__catalog-header {
+        display: flex;
+        flex-direction: row;
+        align-items: flex-end;
+        justify-content: space-between;
+        padding: 20px 18px 14px;
+        border-bottom: 1px solid var(--up-novel-reader-border, rgba(48, 49, 51, 0.12));
+    }
+
+    .up-novel-reader__catalog-title {
+        font-size: 20px;
+        font-weight: 600;
+    }
+
+    .up-novel-reader__catalog-count {
+        color: var(--up-novel-reader-muted, #909399);
+        font-size: 12px;
+    }
+
+    .up-novel-reader__catalog-scroll {
+        flex: 1;
+        min-height: 0;
+    }
+
+    .up-novel-reader__catalog-item {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        min-height: 48px;
+        padding: 0 18px;
+        gap: 10px;
+    }
+
+    .up-novel-reader__catalog-item.is-current {
+        color: var(--up-novel-reader-active, #2979ff);
+        background-color: rgba(41, 121, 255, 0.08);
+    }
+
+    .up-novel-reader__catalog-item.is-locked {
+        opacity: 0.45;
+    }
+
+    .up-novel-reader__catalog-index {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        justify-content: center;
+        width: 24px;
+        color: var(--up-novel-reader-muted, #909399);
+        font-size: 12px;
+    }
+
+    .up-novel-reader__catalog-item-title {
+        flex: 1;
+        overflow: hidden;
+        font-size: 14px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+
+    .up-novel-reader__catalog-empty {
+        padding: 36px 18px;
+        color: var(--up-novel-reader-muted, #909399);
+        text-align: center;
+        font-size: 14px;
+    }
+
+    .up-novel-reader__bookmark-section {
+        margin-top: 10px;
+        padding: 16px 18px 24px;
+        border-top: 1px solid var(--up-novel-reader-border, rgba(48, 49, 51, 0.12));
+    }
+
+    .up-novel-reader__bookmark-heading {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        margin-bottom: 10px;
+        gap: 6px;
+        color: var(--up-novel-reader-muted, #909399);
+        font-size: 13px;
+    }
+
+    .up-novel-reader__bookmark-item {
+        display: flex;
+        flex-direction: row;
+        justify-content: space-between;
+        padding: 8px 0;
+        gap: 12px;
+    }
+
+    .up-novel-reader__bookmark-excerpt {
+        flex: 1;
+        overflow: hidden;
+        font-size: 13px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+
+    .up-novel-reader__bookmark-progress {
+        color: var(--up-novel-reader-muted, #909399);
+        font-size: 11px;
+    }
+</style>