diff options
Diffstat (limited to 'ext/js/dictionary/dictionary-importer.js')
| -rw-r--r-- | ext/js/dictionary/dictionary-importer.js | 796 |
1 files changed, 796 insertions, 0 deletions
diff --git a/ext/js/dictionary/dictionary-importer.js b/ext/js/dictionary/dictionary-importer.js new file mode 100644 index 00000000..2c0c7e9c --- /dev/null +++ b/ext/js/dictionary/dictionary-importer.js @@ -0,0 +1,796 @@ +/* + * Copyright (C) 2023 Yomitan Authors + * Copyright (C) 2020-2022 Yomichan Authors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +import * as ajvSchemas0 from '../../lib/validate-schemas.js'; +import { + BlobWriter as BlobWriter0, + TextWriter as TextWriter0, + Uint8ArrayReader as Uint8ArrayReader0, + ZipReader as ZipReader0, + configure +} from '../../lib/zip.js'; +import {stringReverse} from '../core.js'; +import {ExtensionError} from '../core/extension-error.js'; +import {parseJson} from '../core/json.js'; +import {MediaUtil} from '../media/media-util.js'; + +const ajvSchemas = /** @type {import('dictionary-importer').CompiledSchemaValidators} */ (/** @type {unknown} */ (ajvSchemas0)); +const BlobWriter = /** @type {typeof import('@zip.js/zip.js').BlobWriter} */ (/** @type {unknown} */ (BlobWriter0)); +const TextWriter = /** @type {typeof import('@zip.js/zip.js').TextWriter} */ (/** @type {unknown} */ (TextWriter0)); +const Uint8ArrayReader = /** @type {typeof import('@zip.js/zip.js').Uint8ArrayReader} */ (/** @type {unknown} */ (Uint8ArrayReader0)); +const ZipReader = /** @type {typeof import('@zip.js/zip.js').ZipReader} */ (/** @type {unknown} */ (ZipReader0)); + +export class DictionaryImporter { + /** + * @param {import('dictionary-importer-media-loader').GenericMediaLoader} mediaLoader + * @param {import('dictionary-importer').OnProgressCallback} [onProgress] + */ + constructor(mediaLoader, onProgress) { + /** @type {import('dictionary-importer-media-loader').GenericMediaLoader} */ + this._mediaLoader = mediaLoader; + /** @type {import('dictionary-importer').OnProgressCallback} */ + this._onProgress = typeof onProgress === 'function' ? onProgress : () => {}; + /** @type {import('dictionary-importer').ProgressData} */ + this._progressData = this._createProgressData(); + } + + /** + * @param {import('./dictionary-database.js').DictionaryDatabase} dictionaryDatabase + * @param {ArrayBuffer} archiveContent + * @param {import('dictionary-importer').ImportDetails} details + * @returns {Promise<import('dictionary-importer').ImportResult>} + */ + async importDictionary(dictionaryDatabase, archiveContent, details) { + if (!dictionaryDatabase) { + throw new Error('Invalid database'); + } + if (!dictionaryDatabase.isPrepared()) { + throw new Error('Database is not ready'); + } + + this._progressReset(); + + configure({ + workerScripts: { + deflate: ['../../lib/z-worker.js'], + inflate: ['../../lib/z-worker.js'] + } + }); + + // Read archive + const zipFileReader = new Uint8ArrayReader(new Uint8Array(archiveContent)); + const zipReader = new ZipReader(zipFileReader); + const zipEntries = await zipReader.getEntries(); + /** @type {import('dictionary-importer').ArchiveFileMap} */ + const fileMap = new Map(); + for (const entry of zipEntries) { + fileMap.set(entry.filename, entry); + } + // Read and validate index + const indexFileName = 'index.json'; + const indexFile = fileMap.get(indexFileName); + if (typeof indexFile === 'undefined') { + throw new Error('No dictionary index found in archive'); + } + const indexFile2 = /** @type {import('@zip.js/zip.js').Entry} */ (indexFile); + + const indexContent = await this._getData(indexFile2, new TextWriter()); + const index = /** @type {import('dictionary-data').Index} */ (parseJson(indexContent)); + + if (!ajvSchemas.dictionaryIndex(index)) { + throw this._formatAjvSchemaError(ajvSchemas.dictionaryIndex, indexFileName); + } + + const dictionaryTitle = index.title; + const version = typeof index.format === 'number' ? index.format : index.version; + + if (typeof version !== 'number' || !dictionaryTitle || !index.revision) { + throw new Error('Unrecognized dictionary format'); + } + + // Verify database is not already imported + if (await dictionaryDatabase.dictionaryExists(dictionaryTitle)) { + throw new Error('Dictionary is already imported'); + } + + // Load schemas + this._progressNextStep(0); + const dataBankSchemas = this._getDataBankSchemas(version); + + // Files + /** @type {import('dictionary-importer').QueryDetails} */ + const queryDetails = new Map([ + ['termFiles', /^term_bank_(\d+)\.json$/], + ['termMetaFiles', /^term_meta_bank_(\d+)\.json$/], + ['kanjiFiles', /^kanji_bank_(\d+)\.json$/], + ['kanjiMetaFiles', /^kanji_meta_bank_(\d+)\.json$/], + ['tagFiles', /^tag_bank_(\d+)\.json$/] + ]); + const {termFiles, termMetaFiles, kanjiFiles, kanjiMetaFiles, tagFiles} = Object.fromEntries(this._getArchiveFiles(fileMap, queryDetails)); + + // Load data + this._progressNextStep(termFiles.length + termMetaFiles.length + kanjiFiles.length + kanjiMetaFiles.length + tagFiles.length); + const termList = await ( + version === 1 ? + this._readFileSequence(termFiles, this._convertTermBankEntryV1.bind(this), dataBankSchemas[0], dictionaryTitle) : + this._readFileSequence(termFiles, this._convertTermBankEntryV3.bind(this), dataBankSchemas[0], dictionaryTitle) + ); + const termMetaList = await this._readFileSequence(termMetaFiles, this._convertTermMetaBankEntry.bind(this), dataBankSchemas[1], dictionaryTitle); + const kanjiList = await ( + version === 1 ? + this._readFileSequence(kanjiFiles, this._convertKanjiBankEntryV1.bind(this), dataBankSchemas[2], dictionaryTitle) : + this._readFileSequence(kanjiFiles, this._convertKanjiBankEntryV3.bind(this), dataBankSchemas[2], dictionaryTitle) + ); + const kanjiMetaList = await this._readFileSequence(kanjiMetaFiles, this._convertKanjiMetaBankEntry.bind(this), dataBankSchemas[3], dictionaryTitle); + const tagList = await this._readFileSequence(tagFiles, this._convertTagBankEntry.bind(this), dataBankSchemas[4], dictionaryTitle); + this._addOldIndexTags(index, tagList, dictionaryTitle); + + // Prefix wildcard support + const prefixWildcardsSupported = !!details.prefixWildcardsSupported; + if (prefixWildcardsSupported) { + for (const entry of termList) { + entry.expressionReverse = stringReverse(entry.expression); + entry.readingReverse = stringReverse(entry.reading); + } + } + + // Extended data support + this._progressNextStep(termList.length); + const formatProgressInterval = 1000; + /** @type {import('dictionary-importer').ImportRequirement[]} */ + const requirements = []; + for (let i = 0, ii = termList.length; i < ii; ++i) { + const entry = termList[i]; + const glossaryList = entry.glossary; + for (let j = 0, jj = glossaryList.length; j < jj; ++j) { + const glossary = glossaryList[j]; + if (typeof glossary !== 'object' || glossary === null) { continue; } + glossaryList[j] = this._formatDictionaryTermGlossaryObject(glossary, entry, requirements); + } + if ((i % formatProgressInterval) === 0) { + this._progressData.index = i; + this._progress(); + } + } + this._progress(); + + // Async requirements + this._progressNextStep(requirements.length); + const {media} = await this._resolveAsyncRequirements(requirements, fileMap); + + // Add dictionary descriptor + this._progressNextStep(termList.length + termMetaList.length + kanjiList.length + kanjiMetaList.length + tagList.length + media.length); + + /** @type {import('dictionary-importer').SummaryCounts} */ + const counts = { + terms: {total: termList.length}, + termMeta: this._getMetaCounts(termMetaList), + kanji: {total: kanjiList.length}, + kanjiMeta: this._getMetaCounts(kanjiMetaList), + tagMeta: {total: tagList.length}, + media: {total: media.length} + }; + const summary = this._createSummary(dictionaryTitle, version, index, {prefixWildcardsSupported, counts}); + dictionaryDatabase.bulkAdd('dictionaries', [summary], 0, 1); + + // Add data + /** @type {Error[]} */ + const errors = []; + const maxTransactionLength = 1000; + + /** + * @template {import('dictionary-database').ObjectStoreName} T + * @param {T} objectStoreName + * @param {import('dictionary-database').ObjectStoreData<T>[]} entries + */ + const bulkAdd = async (objectStoreName, entries) => { + const ii = entries.length; + for (let i = 0; i < ii; i += maxTransactionLength) { + const count = Math.min(maxTransactionLength, ii - i); + + try { + await dictionaryDatabase.bulkAdd(objectStoreName, entries, i, count); + } catch (e) { + errors.push(e instanceof Error ? e : new Error(`${e}`)); + } + + this._progressData.index += count; + this._progress(); + } + }; + + await bulkAdd('terms', termList); + await bulkAdd('termMeta', termMetaList); + await bulkAdd('kanji', kanjiList); + await bulkAdd('kanjiMeta', kanjiMetaList); + await bulkAdd('tagMeta', tagList); + await bulkAdd('media', media); + + this._progress(); + + return {result: summary, errors}; + } + + /** + * @returns {import('dictionary-importer').ProgressData} + */ + _createProgressData() { + return { + stepIndex: 0, + stepCount: 6, + index: 0, + count: 0 + }; + } + + /** */ + _progressReset() { + this._progressData = this._createProgressData(); + this._progress(); + } + + /** + * @param {number} count + */ + _progressNextStep(count) { + ++this._progressData.stepIndex; + this._progressData.index = 0; + this._progressData.count = count; + this._progress(); + } + + /** */ + _progress() { + this._onProgress(this._progressData); + } + + /** + * @param {string} dictionaryTitle + * @param {number} version + * @param {import('dictionary-data').Index} index + * @param {{prefixWildcardsSupported: boolean, counts: import('dictionary-importer').SummaryCounts}} details + * @returns {import('dictionary-importer').Summary} + */ + _createSummary(dictionaryTitle, version, index, details) { + const indexSequenced = index.sequenced; + const {prefixWildcardsSupported, counts} = details; + + /** @type {import('dictionary-importer').Summary} */ + const summary = { + title: dictionaryTitle, + revision: index.revision, + sequenced: typeof indexSequenced === 'boolean' && indexSequenced, + version, + importDate: Date.now(), + prefixWildcardsSupported, + counts + }; + + const {author, url, description, attribution, frequencyMode} = index; + if (typeof author === 'string') { summary.author = author; } + if (typeof url === 'string') { summary.url = url; } + if (typeof description === 'string') { summary.description = description; } + if (typeof attribution === 'string') { summary.attribution = attribution; } + if (typeof frequencyMode === 'string') { summary.frequencyMode = frequencyMode; } + + return summary; + } + + /** + * @param {import('ajv').ValidateFunction} schema + * @param {string} fileName + * @returns {ExtensionError} + */ + _formatAjvSchemaError(schema, fileName) { + const e2 = new ExtensionError(`Dictionary has invalid data in '${fileName}'`); + e2.data = schema.errors; + + return e2; + } + + /** + * @param {number} version + * @returns {import('dictionary-importer').CompiledSchemaNameArray} + */ + _getDataBankSchemas(version) { + const termBank = ( + version === 1 ? + 'dictionaryTermBankV1' : + 'dictionaryTermBankV3' + ); + const termMetaBank = 'dictionaryTermMetaBankV3'; + const kanjiBank = ( + version === 1 ? + 'dictionaryKanjiBankV1' : + 'dictionaryKanjiBankV3' + ); + const kanjiMetaBank = 'dictionaryKanjiMetaBankV3'; + const tagBank = 'dictionaryTagBankV3'; + + return [termBank, termMetaBank, kanjiBank, kanjiMetaBank, tagBank]; + } + + /** + * @param {import('dictionary-data').TermGlossaryText|import('dictionary-data').TermGlossaryImage|import('dictionary-data').TermGlossaryStructuredContent} data + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @returns {import('dictionary-data').TermGlossary} + * @throws {Error} + */ + _formatDictionaryTermGlossaryObject(data, entry, requirements) { + switch (data.type) { + case 'text': + return data.text; + case 'image': + return this._formatDictionaryTermGlossaryImage(data, entry, requirements); + case 'structured-content': + return this._formatStructuredContent(data, entry, requirements); + default: + throw new Error(`Unhandled data type: ${/** @type {import('core').SerializableObject} */ (data).type}`); + } + } + + /** + * @param {import('dictionary-data').TermGlossaryImage} data + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @returns {import('dictionary-data').TermGlossaryImage} + */ + _formatDictionaryTermGlossaryImage(data, entry, requirements) { + /** @type {import('dictionary-data').TermGlossaryImage} */ + const target = { + type: 'image', + path: '' // Will be populated during requirement resolution + }; + requirements.push({type: 'image', target, source: data, entry}); + return target; + } + + /** + * @param {import('dictionary-data').TermGlossaryStructuredContent} data + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @returns {import('dictionary-data').TermGlossaryStructuredContent} + */ + _formatStructuredContent(data, entry, requirements) { + const content = this._prepareStructuredContent(data.content, entry, requirements); + return { + type: 'structured-content', + content + }; + } + + /** + * @param {import('structured-content').Content} content + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @returns {import('structured-content').Content} + */ + _prepareStructuredContent(content, entry, requirements) { + if (typeof content === 'string' || !(typeof content === 'object' && content !== null)) { + return content; + } + if (Array.isArray(content)) { + for (let i = 0, ii = content.length; i < ii; ++i) { + content[i] = this._prepareStructuredContent(content[i], entry, requirements); + } + return content; + } + const {tag} = content; + switch (tag) { + case 'img': + return this._prepareStructuredContentImage(content, entry, requirements); + } + const childContent = content.content; + if (typeof childContent !== 'undefined') { + content.content = this._prepareStructuredContent(childContent, entry, requirements); + } + return content; + } + + /** + * @param {import('structured-content').ImageElement} content + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @returns {import('structured-content').ImageElement} + */ + _prepareStructuredContentImage(content, entry, requirements) { + /** @type {import('structured-content').ImageElement} */ + const target = { + tag: 'img', + path: '' // Will be populated during requirement resolution + }; + requirements.push({type: 'structured-content-image', target, source: content, entry}); + return target; + } + + /** + * @param {import('dictionary-importer').ImportRequirement[]} requirements + * @param {import('dictionary-importer').ArchiveFileMap} fileMap + * @returns {Promise<{media: import('dictionary-database').MediaDataArrayBufferContent[]}>} + */ + async _resolveAsyncRequirements(requirements, fileMap) { + /** @type {Map<string, import('dictionary-database').MediaDataArrayBufferContent>} */ + const media = new Map(); + /** @type {import('dictionary-importer').ImportRequirementContext} */ + const context = {fileMap, media}; + + for (const requirement of requirements) { + await this._resolveAsyncRequirement(context, requirement); + } + + return { + media: [...media.values()] + }; + } + + /** + * @param {import('dictionary-importer').ImportRequirementContext} context + * @param {import('dictionary-importer').ImportRequirement} requirement + */ + async _resolveAsyncRequirement(context, requirement) { + switch (requirement.type) { + case 'image': + await this._resolveDictionaryTermGlossaryImage( + context, + requirement.target, + requirement.source, + requirement.entry + ); + break; + case 'structured-content-image': + await this._resolveStructuredContentImage( + context, + requirement.target, + requirement.source, + requirement.entry + ); + break; + default: + return; + } + ++this._progressData.index; + this._progress(); + } + + /** + * @param {import('dictionary-importer').ImportRequirementContext} context + * @param {import('dictionary-data').TermGlossaryImage} target + * @param {import('dictionary-data').TermGlossaryImage} source + * @param {import('dictionary-database').DatabaseTermEntry} entry + */ + async _resolveDictionaryTermGlossaryImage(context, target, source, entry) { + await this._createImageData(context, target, source, entry); + } + + /** + * @param {import('dictionary-importer').ImportRequirementContext} context + * @param {import('structured-content').ImageElement} target + * @param {import('structured-content').ImageElement} source + * @param {import('dictionary-database').DatabaseTermEntry} entry + */ + async _resolveStructuredContentImage(context, target, source, entry) { + const {verticalAlign, sizeUnits} = source; + await this._createImageData(context, target, source, entry); + if (typeof verticalAlign === 'string') { target.verticalAlign = verticalAlign; } + if (typeof sizeUnits === 'string') { target.sizeUnits = sizeUnits; } + } + + /** + * @param {import('dictionary-importer').ImportRequirementContext} context + * @param {import('structured-content').ImageElementBase} target + * @param {import('structured-content').ImageElementBase} source + * @param {import('dictionary-database').DatabaseTermEntry} entry + */ + async _createImageData(context, target, source, entry) { + const { + path, + width: preferredWidth, + height: preferredHeight, + title, + alt, + description, + pixelated, + imageRendering, + appearance, + background, + collapsed, + collapsible + } = source; + const {width, height} = await this._getImageMedia(context, path, entry); + target.path = path; + target.width = width; + target.height = height; + if (typeof preferredWidth === 'number') { target.preferredWidth = preferredWidth; } + if (typeof preferredHeight === 'number') { target.preferredHeight = preferredHeight; } + if (typeof title === 'string') { target.title = title; } + if (typeof alt === 'string') { target.alt = alt; } + if (typeof description === 'string') { target.description = description; } + if (typeof pixelated === 'boolean') { target.pixelated = pixelated; } + if (typeof imageRendering === 'string') { target.imageRendering = imageRendering; } + if (typeof appearance === 'string') { target.appearance = appearance; } + if (typeof background === 'boolean') { target.background = background; } + if (typeof collapsed === 'boolean') { target.collapsed = collapsed; } + if (typeof collapsible === 'boolean') { target.collapsible = collapsible; } + } + + /** + * @param {import('dictionary-importer').ImportRequirementContext} context + * @param {string} path + * @param {import('dictionary-database').DatabaseTermEntry} entry + * @returns {Promise<import('dictionary-database').MediaDataArrayBufferContent>} + */ + async _getImageMedia(context, path, entry) { + const {media} = context; + const {dictionary} = entry; + + /** + * @param {string} message + * @returns {Error} + */ + const createError = (message) => { + const {expression, reading} = entry; + const readingSource = reading.length > 0 ? ` (${reading})` : ''; + return new Error(`${message} at path ${JSON.stringify(path)} for ${expression}${readingSource} in ${dictionary}`); + }; + + // Check if already added + let mediaData = media.get(path); + if (typeof mediaData !== 'undefined') { + if (MediaUtil.getFileExtensionFromImageMediaType(mediaData.mediaType) === null) { + throw createError('Media file is not a valid image'); + } + return mediaData; + } + + // Find file in archive + const file = context.fileMap.get(path); + if (typeof file === 'undefined') { + throw createError('Could not find image'); + } + + // Load file content + let content = await (await this._getData(file, new BlobWriter())).arrayBuffer(); + + const mediaType = MediaUtil.getImageMediaTypeFromFileName(path); + if (mediaType === null) { + throw createError('Could not determine media type for image'); + } + + // Load image data + let width; + let height; + try { + ({content, width, height} = await this._mediaLoader.getImageDetails(content, mediaType)); + } catch (e) { + throw createError('Could not load image'); + } + + // Create image data + mediaData = { + dictionary, + path, + mediaType, + width, + height, + content + }; + media.set(path, mediaData); + + return mediaData; + } + + /** + * @param {import('dictionary-data').TermV1} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseTermEntry} + */ + _convertTermBankEntryV1(entry, dictionary) { + let [expression, reading, definitionTags, rules, score, ...glossary] = entry; + expression = this._normalizeTermOrReading(expression); + reading = this._normalizeTermOrReading(reading.length > 0 ? reading : expression); + return {expression, reading, definitionTags, rules, score, glossary, dictionary}; + } + + /** + * @param {import('dictionary-data').TermV3} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseTermEntry} + */ + _convertTermBankEntryV3(entry, dictionary) { + let [expression, reading, definitionTags, rules, score, glossary, sequence, termTags] = entry; + expression = this._normalizeTermOrReading(expression); + reading = this._normalizeTermOrReading(reading.length > 0 ? reading : expression); + return {expression, reading, definitionTags, rules, score, glossary, sequence, termTags, dictionary}; + } + + /** + * @param {import('dictionary-data').TermMeta} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseTermMeta} + */ + _convertTermMetaBankEntry(entry, dictionary) { + const [expression, mode, data] = entry; + return /** @type {import('dictionary-database').DatabaseTermMeta} */ ({expression, mode, data, dictionary}); + } + + /** + * @param {import('dictionary-data').KanjiV1} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseKanjiEntry} + */ + _convertKanjiBankEntryV1(entry, dictionary) { + const [character, onyomi, kunyomi, tags, ...meanings] = entry; + return {character, onyomi, kunyomi, tags, meanings, dictionary}; + } + + /** + * @param {import('dictionary-data').KanjiV3} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseKanjiEntry} + */ + _convertKanjiBankEntryV3(entry, dictionary) { + const [character, onyomi, kunyomi, tags, meanings, stats] = entry; + return {character, onyomi, kunyomi, tags, meanings, stats, dictionary}; + } + + /** + * @param {import('dictionary-data').KanjiMeta} entry + * @param {string} dictionary + * @returns {import('dictionary-database').DatabaseKanjiMeta} + */ + _convertKanjiMetaBankEntry(entry, dictionary) { + const [character, mode, data] = entry; + return {character, mode, data, dictionary}; + } + + /** + * @param {import('dictionary-data').Tag} entry + * @param {string} dictionary + * @returns {import('dictionary-database').Tag} + */ + _convertTagBankEntry(entry, dictionary) { + const [name, category, order, notes, score] = entry; + return {name, category, order, notes, score, dictionary}; + } + + /** + * @param {import('dictionary-data').Index} index + * @param {import('dictionary-database').Tag[]} results + * @param {string} dictionary + */ + _addOldIndexTags(index, results, dictionary) { + const {tagMeta} = index; + if (typeof tagMeta !== 'object' || tagMeta === null) { return; } + for (const [name, value] of Object.entries(tagMeta)) { + const {category, order, notes, score} = value; + results.push({name, category, order, notes, score, dictionary}); + } + } + + /** + * @param {import('dictionary-importer').ArchiveFileMap} fileMap + * @param {import('dictionary-importer').QueryDetails} queryDetails + * @returns {import('dictionary-importer').QueryResult} + */ + _getArchiveFiles(fileMap, queryDetails) { + /** @type {import('dictionary-importer').QueryResult} */ + const results = new Map(); + for (const [name, value] of fileMap.entries()) { + for (const [fileType, fileNameFormat] of queryDetails.entries()) { + let entries = results.get(fileType); + if (typeof entries === 'undefined') { + entries = []; + results.set(fileType, entries); + } + + if (fileNameFormat.test(name)) { + entries.push(value); + break; + } + } + } + return results; + } + + /** + * @template [TEntry=unknown] + * @template [TResult=unknown] + * @param {import('@zip.js/zip.js').Entry[]} files + * @param {(entry: TEntry, dictionaryTitle: string) => TResult} convertEntry + * @param {import('dictionary-importer').CompiledSchemaName} schemaName + * @param {string} dictionaryTitle + * @returns {Promise<TResult[]>} + */ + async _readFileSequence(files, convertEntry, schemaName, dictionaryTitle) { + const progressData = this._progressData; + let startIndex = 0; + + const results = []; + for (const file of files) { + const content = await this._getData(file, new TextWriter()); + const entries = /** @type {unknown} */ (parseJson(content)); + + startIndex = progressData.index; + this._progress(); + + const schema = ajvSchemas[schemaName]; + if (!schema(entries)) { + throw this._formatAjvSchemaError(schema, file.filename); + } + + progressData.index = startIndex + 1; + this._progress(); + + if (Array.isArray(entries)) { + for (const entry of entries) { + results.push(convertEntry(/** @type {TEntry} */ (entry), dictionaryTitle)); + } + } + } + return results; + } + + /** + * @param {import('dictionary-database').DatabaseTermMeta[]|import('dictionary-database').DatabaseKanjiMeta[]} metaList + * @returns {import('dictionary-importer').SummaryMetaCount} + */ + _getMetaCounts(metaList) { + /** @type {Map<string, number>} */ + const countsMap = new Map(); + for (const {mode} of metaList) { + let count = countsMap.get(mode); + count = typeof count !== 'undefined' ? count + 1 : 1; + countsMap.set(mode, count); + } + /** @type {import('dictionary-importer').SummaryMetaCount} */ + const counts = {total: metaList.length}; + for (const [key, value] of countsMap.entries()) { + if (Object.prototype.hasOwnProperty.call(counts, key)) { continue; } + counts[key] = value; + } + return counts; + } + + /** + * @param {string} text + * @returns {string} + */ + _normalizeTermOrReading(text) { + // Note: this function should not perform String.normalize on the text, + // as it will normalize characters in an undesirable way. + // Thus, this function is currently a no-op. + // Example: + // - '\u9038'.normalize('NFC') => '\u9038' (逸) + // - '\ufa67'.normalize('NFC') => '\u9038' (逸 => 逸) + return text; + } + + /** + * @template [T=unknown] + * @param {import('@zip.js/zip.js').Entry} entry + * @param {import('@zip.js/zip.js').Writer<T>|import('@zip.js/zip.js').WritableWriter} writer + * @returns {Promise<T>} + */ + async _getData(entry, writer) { + if (typeof entry.getData === 'undefined') { + throw new Error(`Cannot read ${entry.filename}`); + } + return await entry.getData(writer); + } +} |