@tolgee/cli 2.0.4 → 2.1.0

package/dist/cli.js

@@ -4,7 +4,7 @@ import ansi from 'ansi-colors';
 import { getApiKey, savePak, savePat } from './config/credentials.js';
 import loadTolgeeRc from './config/tolgeerc.js';
 import { setDebug, info, error, exitWithError } from './utils/logger.js';
-import { API_KEY_OPT, API_URL_OPT, CONFIG_OPT, EXTRACTOR, FILE_PATTERNS, FORMAT_OPT, PROJECT_ID_OPT, } from './options.js';
+import { API_KEY_OPT, API_URL_OPT, CONFIG_OPT, DEFAULT_NAMESPACE, EXTRACTOR, FILE_PATTERNS, FORMAT_OPT, STRICT_NAMESPACE, PARSER, PROJECT_ID_OPT, STRICT_NAMESPACE_NEGATION, VERBOSE, } from './options.js';
 import { API_KEY_PAK_PREFIX, API_KEY_PAT_PREFIX, DEFAULT_API_URL, VERSION, } from './constants.js';
 import { Login, Logout } from './commands/login.js';
 import PushCommand from './commands/push.js';
@@ -87,43 +87,35 @@ const preHandler = (config) => async function (prog, cmd) {
         cmd.setOptionValue('client', client);
     }
     // Apply verbosity
-    setDebug(prog.opts().verbose);
+    setDebug(Boolean(prog.opts().verbose));
 };
 const program = new Command('tolgee')
     .version(VERSION)
     .configureOutput({ writeErr: error })
-    .description('Command Line Interface to interact with the Tolgee Platform')
-    .option('-v, --verbose', 'Enable verbose logging.');
+    .description('Command Line Interface to interact with the Tolgee Platform');
 // get config path to update defaults
 const configPath = getSingleOption(CONFIG_OPT, process.argv);
 async function loadConfig(program) {
     const tgConfig = await loadTolgeeRc(configPath);
-    if (tgConfig) {
-        [program, ...program.commands].forEach((cmd) => cmd.options.forEach((opt) => {
-            const key = opt.attributeName();
-            const value = tgConfig[key];
-            if (value) {
-                const parsedValue = opt.parseArg
-                    ? opt.parseArg(value, undefined)
-                    : value;
-                cmd.setOptionValueWithSource(key, parsedValue, 'config');
-            }
-        }));
-    }
     return tgConfig ?? {};
 }
 async function run() {
     try {
+        const config = await loadConfig(program);
+        program.hook('preAction', preHandler(config));
         // Global options
+        program.addOption(VERBOSE);
         program.addOption(CONFIG_OPT);
-        program.addOption(API_URL_OPT.default(DEFAULT_API_URL));
+        program.addOption(API_URL_OPT.default(config.apiUrl ?? DEFAULT_API_URL));
         program.addOption(API_KEY_OPT);
-        program.addOption(PROJECT_ID_OPT.default(-1));
-        program.addOption(FORMAT_OPT.default('JSON_TOLGEE'));
-        program.addOption(EXTRACTOR);
-        program.addOption(FILE_PATTERNS);
-        const config = await loadConfig(program);
-        program.hook('preAction', preHandler(config));
+        program.addOption(PROJECT_ID_OPT.default(config.projectId ?? -1));
+        program.addOption(FORMAT_OPT.default(config.format ?? 'JSON_TOLGEE'));
+        program.addOption(EXTRACTOR.default(config.extractor));
+        program.addOption(FILE_PATTERNS.default(config.patterns));
+        program.addOption(PARSER.default(config.parser));
+        program.addOption(STRICT_NAMESPACE.default(config.strictNamespace ?? true));
+        program.addOption(STRICT_NAMESPACE_NEGATION);
+        program.addOption(DEFAULT_NAMESPACE.default(config.defaultNamespace));
         // Register commands
         program.addCommand(Login);
         program.addCommand(Logout);

package/dist/commands/extract/check.js

@@ -2,14 +2,10 @@ import { relative } from 'path';
 import { Command } from 'commander';
 import { extractKeysOfFiles } from '../../extractor/runner.js';
 import { WarningMessages, emitGitHubWarning, } from '../../extractor/warnings.js';
-import { exitWithError, loading } from '../../utils/logger.js';
+import { loading } from '../../utils/logger.js';
 const lintHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const patterns = opts.patterns;
-    if (!patterns?.length) {
-        exitWithError('Missing option --patterns or config.patterns option');
-    }
-    const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+    const extracted = await loading('Analyzing code...', extractKeysOfFiles(opts));
     let warningCount = 0;
     let filesCount = 0;
     for (const [file, { warnings }] of extracted) {

package/dist/commands/extract/print.js

@@ -2,14 +2,10 @@ import { relative } from 'path';
 import { Command } from 'commander';
 import { extractKeysOfFiles } from '../../extractor/runner.js';
 import { WarningMessages } from '../../extractor/warnings.js';
-import { exitWithError, loading } from '../../utils/logger.js';
+import { loading } from '../../utils/logger.js';
 const printHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const patterns = opts.patterns;
-    if (!patterns?.length) {
-        exitWithError('Missing option --patterns or config.patterns option');
-    }
-    const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+    const extracted = await loading('Analyzing code...', extractKeysOfFiles(opts));
     let warningCount = 0;
     const keySet = new Set();
     for (const [file, { keys, warnings }] of extracted) {

package/dist/commands/sync/compare.js

@@ -3,15 +3,11 @@ import ansi from 'ansi-colors';
 import { compareKeys, printKey } from './syncUtils.js';
 import { extractKeysOfFiles, filterExtractionResult, } from '../../extractor/runner.js';
 import { dumpWarnings } from '../../extractor/warnings.js';
-import { exitWithError, loading } from '../../utils/logger.js';
+import { loading } from '../../utils/logger.js';
 import { handleLoadableError } from '../../client/TolgeeClient.js';
 const asyncHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const patterns = opts.patterns?.length ? opts.patterns : config.patterns;
-    if (!patterns?.length) {
-        exitWithError('Missing argument <patterns>');
-    }
-    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(opts));
     dumpWarnings(rawKeys);
     const localKeys = filterExtractionResult(rawKeys);
     const loadable = await opts.client.GET('/v2/projects/{projectId}/all-keys', { params: { path: { projectId: opts.client.getProjectId() } } });

package/dist/commands/sync/sync.js

@@ -33,11 +33,7 @@ async function askForConfirmation(keys, operation) {
 }
 const syncHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const patterns = opts.patterns?.length ? opts.patterns : config.patterns;
-    if (!patterns?.length) {
-        exitWithError('Missing argument <patterns>');
-    }
-    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(opts));
     const warnCount = dumpWarnings(rawKeys);
     if (!opts.continueOnWarning && warnCount) {
         console.log(ansi.bold.red('Aborting as warnings have been emitted.'));

package/dist/commands/tag.js

@@ -9,11 +9,7 @@ const tagHandler = (config) => async function () {
         if (opts.filterExtracted && opts.filterNotExtracted) {
             exitWithError('Use either "--filter-extracted" or "--filter-not-extracted", not both');
         }
-        const patterns = opts.patterns;
-        if (!patterns?.length) {
-            exitWithError('Missing option --patterns or config.patterns option');
-        }
-        const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+        const extracted = await loading('Analyzing code...', extractKeysOfFiles(opts));
         const keys = [...extracted.values()].flatMap((item) => item.keys);
         extractedKeys = keys.map((key) => ({
             name: key.keyName,

package/dist/config/tolgeerc.js

@@ -26,17 +26,18 @@ function parseConfig(input, configDir) {
             throw new Error('Invalid config: projectId should be an integer representing your project Id');
         }
     }
+    // convert relative paths in config to absolute
     if (rc.extractor !== undefined) {
         rc.extractor = resolve(configDir, rc.extractor);
         if (!existsSync(rc.extractor)) {
             throw new Error(`Invalid config: extractor points to a file that does not exists (${rc.extractor})`);
         }
     }
-    if (rc.delimiter !== undefined) {
-        rc.delimiter = rc.delimiter || '';
+    // convert relative paths in config to absolute
+    if (rc.patterns !== undefined) {
+        rc.patterns = rc.patterns.map((pattern) => resolve(configDir, pattern));
     }
     // convert relative paths in config to absolute
-    // so it's always relative to config location
     if (rc.push?.files) {
         rc.push.files = rc.push.files.map((r) => ({
             ...r,
@@ -46,9 +47,6 @@ function parseConfig(input, configDir) {
     if (rc.pull?.path !== undefined) {
         rc.pull.path = resolve(configDir, rc.pull.path);
     }
-    if (rc.patterns !== undefined) {
-        rc.patterns = rc.patterns.map((pattern) => resolve(configDir, pattern));
-    }
     return rc;
 }
 async function getSchema() {

package/dist/extractor/extractor.js

@@ -1,72 +1,46 @@
-import { extname } from 'path';
-import { interpret } from 'xstate';
-import reactExtractorMachine from './machines/react.js';
-import vueExtractorMachine from './machines/vue/extract.js';
-import svelteExtractorMachine from './machines/svelte.js';
-import commentsExtractorMachine from './machines/comments.js';
-import vueSfcProcessor from './processors/vueSfc.js';
 import tokenizer from './tokenizer.js';
-const REACT_EXTS = [
-    '.js',
-    '.mjs',
-    '.cjs',
-    '.ts',
-    '.mts',
-    '.cts',
-    '.jsx',
-    '.tsx',
-];
-const VUE_EXTS = REACT_EXTS;
-const ALL_EXTS = [
-    '.js',
-    '.mjs',
-    '.cjs',
-    '.ts',
-    '.mts',
-    '.cts',
-    '.jsx',
-    '.tsx',
-    '.svelte',
-];
-function pickMachine(code, ext) {
-    if (REACT_EXTS.includes(ext) && code.includes('@tolgee/react')) {
-        return reactExtractorMachine;
+import { ParserReact } from './parserReact/ParserReact.js';
+import { tokensList } from './visualizers/printTokens.js';
+import { visualizeRules } from './visualizers/visualizeRules.js';
+import { ParserVue } from './parserVue/ParserVue.js';
+import { ParserSvelte } from './parserSvelte/ParserSvelte.js';
+function pickParser(format) {
+    switch (format) {
+        case 'react':
+            return ParserReact();
+        case 'vue':
+            return ParserVue();
+        case 'svelte':
+            return ParserSvelte();
     }
-    if (VUE_EXTS.includes(ext) && code.includes('@tolgee/vue')) {
-        return vueExtractorMachine;
-    }
-    if (ext === '.svelte' && code.includes('@tolgee/svelte')) {
-        return svelteExtractorMachine;
-    }
-    if (ALL_EXTS.includes(ext) &&
-        (code.includes('@tolgee-key') || code.includes('@tolgee-ignore'))) {
-        return commentsExtractorMachine;
-    }
-    return null;
 }
-export default async function extractor(code, fileName) {
-    const ext = extname(fileName);
-    if (ext === '.vue' &&
-        (code.includes('$t') ||
-            code.includes('@tolgee/vue') ||
-            code.includes('@tolgee-key') ||
-            code.includes('@tolgee-ignore'))) {
-        return vueSfcProcessor(code, fileName);
+export async function extractTreeAndReport(code, fileName, parserType, options) {
+    const debug = options.verbose?.includes('extractor');
+    const tokens = (await tokenizer(code, fileName));
+    const parser = pickParser(parserType);
+    const tokensMerged = [];
+    const tokensWithRules = [];
+    let onAccept = undefined;
+    if (debug) {
+        onAccept = (token, type) => {
+            tokensMerged.push(token);
+            tokensWithRules.push({ ...token, customType: type });
+        };
     }
-    const machineSpec = pickMachine(code, ext);
-    if (!machineSpec) {
-        return { warnings: [], keys: [] };
+    const result = parser.parse({
+        tokens,
+        onAccept,
+        options,
+    });
+    if (debug) {
+        console.log(JSON.stringify(result.tree, null, 2));
+        console.log(tokensList(tokensMerged));
+        console.log(visualizeRules(tokensMerged, code));
+        console.log(visualizeRules(tokensWithRules, code));
     }
-    const tokens = await tokenizer(code, fileName);
-    // @ts-ignore -- Types are whacky, complains about withConfig but it's not a problem here.
-    const machine = interpret(machineSpec);
-    machine.start();
-    for (const token of tokens) {
-        machine.send(token);
-    }
-    const snapshot = machine.getSnapshot();
-    return {
-        warnings: snapshot.context.warnings,
-        keys: snapshot.context.keys,
-    };
+    return result;
+}
+export default async function extractor(code, fileName, parserType, options) {
+    const result = await extractTreeAndReport(code, fileName, parserType, options);
+    return result.report;
 }

package/dist/extractor/parser/extractComment.js

@@ -0,0 +1,78 @@
+import JSON5 from 'json5';
+function isValidKeyOverride(data) {
+    if (!('key' in data)) {
+        return false;
+    }
+    if (typeof data.key !== 'string') {
+        return false;
+    }
+    if ('ns' in data && typeof data.ns !== 'string') {
+        return false;
+    }
+    if ('defaultValue' in data && typeof data.defaultValue !== 'string') {
+        return false;
+    }
+    return true;
+}
+function getEndLine(token) {
+    return token.line + (token.token.match(/\n/gm)?.length ?? 0);
+}
+export function extractComment(token) {
+    const comment = token.token.trim();
+    if (comment.startsWith('@tolgee-ignore')) {
+        return {
+            type: 'MAGIC_COMMENT',
+            kind: 'ignore',
+            line: getEndLine(token),
+        };
+    }
+    if (comment.startsWith('@tolgee-key')) {
+        const data = comment.slice(11).trim();
+        // Data is escaped; extract all as string
+        if (data.startsWith('\\')) {
+            return {
+                type: 'MAGIC_COMMENT',
+                kind: 'key',
+                keyName: data.slice(1),
+                line: getEndLine(token),
+            };
+        }
+        // Data is a json5 struct
+        if (data.startsWith('{')) {
+            try {
+                const key = JSON5.parse(data);
+                if (!isValidKeyOverride(key)) {
+                    // No key in the struct; invalid override
+                    return {
+                        type: 'WARNING',
+                        kind: 'W_INVALID_KEY_OVERRIDE',
+                        line: getEndLine(token),
+                    };
+                }
+                else {
+                    return {
+                        type: 'MAGIC_COMMENT',
+                        kind: 'key',
+                        keyName: key.key,
+                        namespace: key.ns,
+                        defaultValue: key.defaultValue,
+                        line: getEndLine(token),
+                    };
+                }
+            }
+            catch {
+                return {
+                    type: 'WARNING',
+                    kind: 'W_MALFORMED_KEY_OVERRIDE',
+                    line: getEndLine(token),
+                };
+            }
+        }
+        return {
+            type: 'MAGIC_COMMENT',
+            kind: 'key',
+            keyName: data,
+            line: getEndLine(token),
+        };
+    }
+}

package/dist/extractor/parser/generalMapper.js

@@ -0,0 +1,82 @@
+export const generalMapper = (token) => {
+    switch (token.type) {
+        // comments
+        case 'punctuation.definition.comment.ts':
+            return 'comment.definition';
+        case 'comment.block.ts':
+        case 'comment.block.documentation.ts':
+            return 'comment.block';
+        case 'comment.line.double-slash.ts':
+            return 'comment.line';
+        // primitives
+        case 'constant.language.null.ts':
+            return 'primitive.null';
+        // plain strings
+        case 'punctuation.definition.string.begin.ts':
+            return 'string.begin';
+        case 'punctuation.definition.string.end.ts':
+            return 'string.end';
+        case 'string.quoted.single.ts':
+        case 'string.quoted.double.ts':
+            return 'string.body';
+        // template strings
+        case 'punctuation.definition.string.template.begin.ts':
+            return 'string.teplate.begin';
+        case 'punctuation.definition.string.template.end.ts':
+            return 'string.template.end';
+        case 'string.template.ts':
+            return 'string.template.body';
+        // variables
+        case 'variable.other.object.ts':
+        case 'variable.other.constant.ts':
+        case 'variable.language.this.ts':
+            return 'variable';
+        // function
+        case 'support.function.dom.ts':
+        case 'entity.name.function.ts':
+            return 'function.call';
+        // "async" word
+        case 'storage.modifier.async.ts':
+            return 'kw.async';
+        // "." accessor
+        case 'punctuation.accessor.ts':
+            return 'acessor.dot';
+        // ":" accessor
+        case 'punctuation.separator.label.ts':
+        case 'punctuation.separator.key-value.ts':
+            return 'acessor.doublecolon';
+        // "," separator
+        case 'punctuation.separator.comma.ts':
+            return 'separator.comma';
+        // "="
+        case 'keyword.operator.assignment.ts':
+            return 'operator.assignment';
+        // curly brackets - blocks
+        case 'punctuation.definition.block.ts':
+            return token.token === '{' ? 'block.begin' : 'block.end';
+        // rounded brackets - expressions
+        case 'punctuation.definition.parameters.begin.ts':
+        case 'punctuation.definition.parameters.end.ts':
+        case 'meta.brace.round.ts':
+            return token.token === '(' ? 'expression.begin' : 'expression.end';
+        case 'meta.brace.square.ts':
+            return token.token === '[' ? 'list.begin' : 'list.end';
+        case 'meta.object-literal.key.ts':
+        case 'entity.name.label.ts':
+            return 'object.key';
+        case 'variable.other.readwrite.ts':
+            return 'variable';
+        // ignore type annotations
+        case 'keyword.control.as.ts':
+            return 'typescript.as';
+        case 'support.type.primitive.ts':
+        case 'entity.name.type.ts':
+            return 'typescript.type.primitive';
+        case 'meta.brace.angle.ts':
+            return token.token === '<'
+                ? 'typescript.expr.begin'
+                : 'typescript.expr.end';
+        case 'keyword.operator.type.ts':
+            return 'typescript.operator';
+    }
+};

package/dist/extractor/parser/generateReport.js

@@ -0,0 +1,161 @@
+import { extractString, isString } from './nodeUtils.js';
+function shouldBeIgnored(context, line) {
+    const commentAtLine = context.commentMap.get(line - 1);
+    const isIgnore = commentAtLine?.type === 'MAGIC_COMMENT' && commentAtLine.kind === 'ignore';
+    if (isIgnore) {
+        context.unusedComments.delete(commentAtLine);
+    }
+    return isIgnore;
+}
+function keyInfoFromComment(context, line) {
+    const commentAtLine = context.commentMap.get(line - 1);
+    const isKeyInfo = commentAtLine?.type === 'MAGIC_COMMENT' && commentAtLine.kind === 'key';
+    if (isKeyInfo) {
+        context.unusedComments.delete(commentAtLine);
+        return {
+            keyName: commentAtLine.keyName,
+            namespace: commentAtLine.namespace,
+            defaultValue: commentAtLine.defaultValue,
+            line: commentAtLine.line,
+        };
+    }
+    return undefined;
+}
+function reportKey(context, node, contextNs) {
+    const { strictNamespace, defaultNamespace } = context.options;
+    const { keys, warnings } = context;
+    const { keyName, namespace: keyNs, defaultValue, line, dependsOnContext, optionsDynamic, } = node;
+    if (shouldBeIgnored(context, line)) {
+        return { keys, warnings };
+    }
+    const overrideInfo = keyInfoFromComment(context, node.line);
+    if (overrideInfo) {
+        // key info is overriten by comment
+        keys.push(overrideInfo);
+        return;
+    }
+    if (!keyName || !isString(keyName)) {
+        // dynamic key or key not present
+        warnings.push({ line, warning: 'W_DYNAMIC_KEY' });
+        return;
+    }
+    if (dependsOnContext && !contextNs && !keyNs && strictNamespace) {
+        // there is no namespace source so namespace is ambiguous
+        warnings.push({ line, warning: 'W_MISSING_T_SOURCE' });
+        return;
+    }
+    if (optionsDynamic && strictNamespace) {
+        // options of the key can't be analyzed, so again ambiguous namespace
+        warnings.push({ line, warning: 'W_DYNAMIC_OPTIONS' });
+        return;
+    }
+    const namespace = keyNs ?? (dependsOnContext ? contextNs?.name : undefined);
+    if (namespace && !isString(namespace)) {
+        // namespace is dynamic
+        if (namespace === contextNs?.name) {
+            // namespace coming from context
+            warnings.push({ line, warning: 'W_UNRESOLVABLE_NAMESPACE' });
+        }
+        else {
+            // namespace is directly on key
+            warnings.push({
+                line,
+                warning: 'W_DYNAMIC_NAMESPACE',
+            });
+        }
+        return;
+    }
+    if (defaultValue !== undefined && !isString(defaultValue)) {
+        // this is just warning, we can still extract
+        warnings.push({ line, warning: 'W_DYNAMIC_DEFAULT_VALUE' });
+    }
+    keys.push({
+        line,
+        keyName: extractString(keyName),
+        namespace: extractString(namespace) ?? defaultNamespace,
+        defaultValue: extractString(defaultValue),
+    });
+}
+function reportNs(context, node) {
+    const { warnings } = context;
+    const { line, name } = node;
+    if (name && !isString(name)) {
+        warnings.push({ line, warning: 'W_DYNAMIC_NAMESPACE' });
+    }
+}
+function reportGeneral(context, node, contextNs) {
+    if (!node) {
+        return;
+    }
+    if (node.type === 'expr' || node.type === 'array') {
+        let namespace = contextNs;
+        for (const item of node.values) {
+            if (item.type === 'nsInfo') {
+                const oldNamespace = namespace;
+                if (!shouldBeIgnored(context, item.line)) {
+                    reportNs(context, item);
+                    namespace = item;
+                }
+                // there might be nested stuff
+                reportGeneral(context, item.name, oldNamespace);
+                for (const i of item.values) {
+                    reportGeneral(context, i, oldNamespace);
+                }
+            }
+            else {
+                reportGeneral(context, item, namespace);
+            }
+        }
+    }
+    else if (node.type === 'keyInfo') {
+        reportKey(context, node, contextNs);
+        // there might be nested stuff
+        reportGeneral(context, node.keyName, contextNs);
+        reportGeneral(context, node.namespace, contextNs);
+        reportGeneral(context, node.defaultValue, contextNs);
+        for (const i of node.values) {
+            reportGeneral(context, i, contextNs);
+        }
+    }
+    else if (node.type === 'dict') {
+        for (const item of Object.values(node.value)) {
+            reportGeneral(context, item, contextNs);
+        }
+        // go through values with unknown keynames
+        for (const item of node.unknown) {
+            reportGeneral(context, item, contextNs);
+        }
+    }
+}
+export function generateReport({ node, contextNs, comments, options, }) {
+    const commentMap = new Map();
+    comments.forEach((item) => {
+        commentMap.set(item.line, item);
+    });
+    const unusedComments = new Set(comments);
+    const context = {
+        commentMap,
+        unusedComments,
+        options,
+        keys: [],
+        warnings: [],
+    };
+    reportGeneral(context, node, contextNs);
+    unusedComments.forEach((value) => {
+        if (value.type === 'WARNING') {
+            context.warnings.push({ line: value.line, warning: value.kind });
+        }
+        else if (value.type === 'MAGIC_COMMENT' && value.kind === 'key') {
+            context.keys.push({
+                keyName: value.keyName,
+                namespace: value.namespace,
+                defaultValue: value.defaultValue,
+                line: value.line,
+            });
+        }
+        else if (value.type === 'MAGIC_COMMENT' && value.kind === 'ignore') {
+            context.warnings.push({ line: value.line, warning: 'W_UNUSED_IGNORE' });
+        }
+    });
+    return { keys: context.keys, warnings: context.warnings };
+}

package/dist/extractor/parser/iterator.js

@@ -0,0 +1,37 @@
+export const createIterator = (items) => {
+    const iterator = items[Symbol.iterator]();
+    let currentItem;
+    let nextItem = iterator.next();
+    const listeners = [];
+    let currentContext = undefined;
+    const self = {
+        getLineNumber() {
+            return currentItem?.line ?? 0;
+        },
+        current() {
+            return currentItem;
+        },
+        peek() {
+            return nextItem.done ? undefined : nextItem.value;
+        },
+        onAccept(listener) {
+            listeners.push(listener);
+        },
+        setLabel(context) {
+            currentContext = context;
+        },
+        getLabel() {
+            return currentContext;
+        },
+        next() {
+            const value = self.peek();
+            if (currentItem) {
+                listeners.forEach((cb) => cb(currentItem, currentContext));
+            }
+            currentItem = nextItem.done ? undefined : nextItem.value;
+            nextItem = iterator.next();
+            return value;
+        },
+    };
+    return self;
+};