uview-plus 3.8.86 → 3.8.106

package/components/u-novel-reader/layout-engine.js

@@ -0,0 +1,225 @@
+import { measureTextWidth } from './measure-adapter'
+
+const CJK_PATTERN = /[\u3400-\u9fff\u3040-\u30ff\uff00-\uffef]/
+
+function createUnit(text, startOffset, endOffset) {
+    return {
+        text,
+        startOffset,
+        endOffset
+    }
+}
+
+function tokenizeText(text) {
+    const units = []
+    let token = ''
+    let tokenStart = 0
+    let offset = 0
+
+    const flushToken = () => {
+        if (token) {
+            units.push(createUnit(token, tokenStart, offset))
+            token = ''
+        }
+    }
+
+    Array.from(String(text)).forEach((character) => {
+        const startOffset = offset
+        offset += character.length
+        if (CJK_PATTERN.test(character) || /\s/.test(character)) {
+            flushToken()
+            units.push(createUnit(character, startOffset, offset))
+            tokenStart = offset
+            return
+        }
+        if (!token) tokenStart = startOffset
+        token += character
+    })
+    flushToken()
+    return units
+}
+
+function splitUnit(unit) {
+    if (unit.text.length <= 1) return [unit]
+    const result = []
+    let offset = unit.startOffset
+    Array.from(unit.text).forEach((character) => {
+        const nextOffset = offset + character.length
+        result.push(createUnit(character, offset, nextOffset))
+        offset = nextOffset
+    })
+    return result
+}
+
+function lineFromUnits(units) {
+    return {
+        text: units.map((unit) => unit.text).join(''),
+        startOffset: units[0].startOffset,
+        endOffset: units[units.length - 1].endOffset
+    }
+}
+
+export function createLayoutKey({
+    chapterId = '',
+    settings = {},
+    width = 0,
+    height = 0
+} = {}) {
+    return JSON.stringify({
+        chapterId,
+        width,
+        height,
+        fontSize: settings.fontSize,
+        lineHeight: settings.lineHeight,
+        paragraphSpacing: settings.paragraphSpacing,
+        contentWidth: settings.contentWidth,
+        fontFamily: settings.fontFamily,
+        fontWeight: settings.fontWeight
+    })
+}
+
+export function wrapText(text, width, measureText = measureTextWidth) {
+    const source = String(text == null ? '' : text)
+    if (!source) {
+        return [{
+            text: '',
+            startOffset: 0,
+            endOffset: 0
+        }]
+    }
+
+    const units = tokenizeText(source).reduce((result, unit) => {
+        const unitWidth = measureText(unit.text)
+        if (unitWidth > width && unit.text.length > 1) {
+            return result.concat(splitUnit(unit))
+        }
+        result.push(unit)
+        return result
+    }, [])
+    const lines = []
+    let currentUnits = []
+
+    units.forEach((unit) => {
+        const candidateUnits = currentUnits.concat(unit)
+        const candidateText = candidateUnits.map((item) => item.text).join('')
+        if (
+            currentUnits.length &&
+            measureText(candidateText) > width
+        ) {
+            lines.push(lineFromUnits(currentUnits))
+            currentUnits = [unit]
+        } else {
+            currentUnits = candidateUnits
+        }
+    })
+
+    if (currentUnits.length) {
+        lines.push(lineFromUnits(currentUnits))
+    }
+    return lines
+}
+
+function getLineHeight(layout) {
+    const fontSize = Number(layout.fontSize) || 18
+    const lineHeight = Number(layout.lineHeight)
+    if (!Number.isFinite(lineHeight)) return fontSize * 1.8
+    return lineHeight <= 4 ? fontSize * lineHeight : lineHeight
+}
+
+function createPage(lines, index) {
+    if (!lines.length) return null
+    return {
+        index,
+        text: lines.map((line) => line.text).join('\n'),
+        lines,
+        startOffset: lines[0].startOffset,
+        endOffset: lines[lines.length - 1].endOffset
+    }
+}
+
+export function paginateParagraphs(paragraphs = [], layout = {}) {
+    const width = Math.max(1, Number(layout.width) || 320)
+    const height = Math.max(1, Number(layout.height) || 500)
+    const lineHeight = Math.max(1, getLineHeight(layout))
+    const paragraphSpacing = Math.max(0, Number(layout.paragraphSpacing) || 0)
+    const measureText = typeof layout.measureText === 'function'
+        ? layout.measureText
+        : (text) => measureTextWidth(text, layout)
+    const pages = []
+    let lines = []
+    let usedHeight = 0
+
+    const flushPage = () => {
+        const page = createPage(lines, pages.length)
+        if (page) pages.push(page)
+        lines = []
+        usedHeight = 0
+    }
+
+    paragraphs.forEach((paragraph, paragraphIndex) => {
+        const normalizedParagraph = typeof paragraph === 'string'
+            ? {
+                text: paragraph,
+                startOffset: 0,
+                endOffset: paragraph.length
+            }
+            : paragraph
+        const paragraphLines = wrapText(
+            normalizedParagraph && normalizedParagraph.text,
+            width,
+            measureText
+        ).map((line) => ({
+            ...line,
+            startOffset: line.startOffset + (normalizedParagraph.startOffset || 0),
+            endOffset: line.endOffset + (normalizedParagraph.startOffset || 0),
+            paragraphIndex
+        }))
+
+        if (paragraphIndex > 0 && lines.length && usedHeight + paragraphSpacing + lineHeight > height) {
+            flushPage()
+        } else if (paragraphIndex > 0 && lines.length) {
+            usedHeight += paragraphSpacing
+        }
+
+        paragraphLines.forEach((line) => {
+            if (lines.length && usedHeight + lineHeight > height) {
+                flushPage()
+            }
+            lines.push(line)
+            usedHeight += lineHeight
+        })
+    })
+    flushPage()
+
+    return {
+        pages,
+        pageCount: pages.length,
+        charOffsetToPage: pages.map((page) => ({
+            pageIndex: page.index,
+            startOffset: page.startOffset,
+            endOffset: page.endOffset
+        }))
+    }
+}
+
+export function resolveAnchor(pages = [], charOffset = 0) {
+    if (!pages.length) {
+        return {
+            pageIndex: 0,
+            localOffset: 0
+        }
+    }
+    const offset = Math.max(0, Number(charOffset) || 0)
+    const page = pages.find((item) => offset <= item.endOffset) || pages[pages.length - 1]
+    return {
+        pageIndex: page.index,
+        localOffset: Math.max(0, Math.min(page.text.length, offset - page.startOffset))
+    }
+}
+
+export default {
+    createLayoutKey,
+    wrapText,
+    paginateParagraphs,
+    resolveAnchor
+}

package/components/u-novel-reader/measure-adapter.js

@@ -0,0 +1,69 @@
+function toNumber(value, fallback) {
+    const number = Number.parseFloat(value)
+    return Number.isFinite(number) ? number : fallback
+}
+
+function getFontSize(style = {}) {
+    return toNumber(style.fontSize, 18)
+}
+
+function getCharacterWidth(character, fontSize) {
+    if (/[\u3400-\u9fff\u3040-\u30ff\uff00-\uffef]/.test(character)) {
+        return fontSize
+    }
+    if (/\s/.test(character)) {
+        return fontSize * 0.28
+    }
+    return fontSize * 0.56
+}
+
+export function normalizeMeasureResult(value) {
+    if (typeof value === 'number') return value
+    if (value && typeof value.width === 'number') return value.width
+    return 0
+}
+
+export function measureTextWidth(text, style = {}, measureText) {
+    if (typeof measureText === 'function') {
+        return normalizeMeasureResult(measureText(String(text), style))
+    }
+    const fontSize = getFontSize(style)
+    return Array.from(String(text)).reduce(
+        (width, character) => width + getCharacterWidth(character, fontSize),
+        0
+    )
+}
+
+export function createMeasureText({ canvasContext, style = {}, measureText } = {}) {
+    if (typeof measureText === 'function') {
+        return (text) => measureTextWidth(text, style, measureText)
+    }
+    if (canvasContext && typeof canvasContext.measureText === 'function') {
+        const fontSize = getFontSize(style)
+        const fontWeight = style.fontWeight || 400
+        const fontFamily = style.fontFamily || 'sans-serif'
+        canvasContext.font = `${fontWeight} ${fontSize}px ${fontFamily}`
+        return (text) => normalizeMeasureResult(canvasContext.measureText(String(text)))
+    }
+    return (text) => measureTextWidth(text, style)
+}
+
+export function measureContainer(selector, vm) {
+    return new Promise((resolve) => {
+        if (typeof uni === 'undefined' || typeof uni.createSelectorQuery !== 'function') {
+            resolve(null)
+            return
+        }
+        const query = vm
+            ? uni.createSelectorQuery().in(vm)
+            : uni.createSelectorQuery()
+        query.select(selector).boundingClientRect((rect) => resolve(rect || null)).exec()
+    })
+}
+
+export default {
+    normalizeMeasureResult,
+    measureTextWidth,
+    createMeasureText,
+    measureContainer
+}

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