@autoanki/plugin-source-yaml/dist/index.js

Extract Anki cards from Markdown fiels

import yaml from 'yaml';
import { z } from 'zod';
const yamlAnkiNoteSchema = z.object({
    id: z.string().optional(),
    deleted: z.boolean().optional(),
    deck: z.string().optional(),
    note_type: z.string(),
    fields: z.record(z.string().min(1), z.string()),
    tags: z.string().array().optional()
}).strict();
function yamlAnkiNoteToParsedNote(yamlNote) {
    return {
        tags: yamlNote.tags ?? [],
        id: yamlNote.id,
        fields: yamlNote.fields,
        deckName: yamlNote.deck,
        modelName: yamlNote.note_type,
        deleted: yamlNote.deleted
    };
}
function parsedNoteToYamlAnkiNote(parsedNote) {
    return {
        id: parsedNote.id,
        fields: parsedNote.fields,
        note_type: parsedNote.modelName,
        deck: parsedNote.deckName,
        tags: parsedNote.tags,
        deleted: parsedNote.deleted
    };
}
export class YamlSourcePlugin {
    async writeBackToInput(inputKey, originalInputContent, notes) {
        const cache = this.yamlParseCache[inputKey];
        for (const note of notes){
            const metadata = note.metadata;
            cache.parsed[metadata.index] = parsedNoteToYamlAnkiNote(note.note);
        }
        return new TextEncoder().encode(yaml.stringify(cache.originallyArray ? cache.parsed : cache.parsed[0], {
            /*
         * Disable folded block string (which I don't like. I use literal block
         * string).
         * TODO: implement YAML stringfication with minimal changes.
         * Using something like:
         *
         * * https://github.com/eemeli/yaml/issues/308
         * * https://github.com/eemeli/yaml/pull/309
         * * https://azimi.me/2015/10/16/yawn-yaml.html
         * * https://github.com/yarnpkg/berry/issues/1463
         *   * https://github.com/paul-soporan/enhanced-yaml
         */ lineWidth: 0
        }));
    }
    async parseFromInput(inputKey, inputContent) {
        const enc = new TextDecoder('utf8');
        const input = enc.decode(inputContent);
        let parsedYaml;
        try {
            parsedYaml = yaml.parse(input);
        } catch (error) {
            this.coreApi.logger.warn(`Unable to parse YAML in ${inputKey}. ${error}`);
            return [];
        }
        const isParsedYamlArray = Array.isArray(parsedYaml);
        if (!isParsedYamlArray) {
            parsedYaml = [
                parsedYaml
            ];
        }
        this.yamlParseCache[inputKey] = {
            parsed: [],
            originallyArray: isParsedYamlArray
        };
        const currentInputCache = this.yamlParseCache[inputKey];
        const outputs = [];
        for (const [i, yamlItem] of parsedYaml.entries()){
            if (yamlItem === null) {
                continue;
            }
            const parseResult = yamlAnkiNoteSchema.safeParse(yamlItem);
            if (parseResult.success) {
                currentInputCache.parsed.push(parseResult.data);
                const note = yamlAnkiNoteToParsedNote(parseResult.data);
                outputs.push({
                    note,
                    metadata: {
                        index: i
                    }
                });
            } else {
                this.coreApi.logger.warn(`Item ${i} in "${inputKey}" is invalid: ${parseResult.error}`);
            }
        }
        return outputs;
    }
    constructor(coreApi){
        this.coreApi = coreApi;
        this.yamlParseCache = {};
    }
}
YamlSourcePlugin.pluginName = '@autoanki/plugin-source-yaml';
export default {
    source: YamlSourcePlugin
};

//# sourceMappingURL=index.js.map