@promptbook/markdown-utils 0.92.0-21 → 0.92.0-22

package/esm/typings/src/_packages/types.index.d.ts

@@ -62,6 +62,7 @@ import type { UsageCounts } from '../execution/Usage';
 import type { UserInterfaceTools } from '../execution/UserInterfaceTools';
 import type { UserInterfaceToolsPromptDialogOptions } from '../execution/UserInterfaceTools';
 import type { FormatSubvalueParser } from '../formats/_common/FormatSubvalueParser';
+import type { FormatSubvalueParserMapValuesOptions } from '../formats/_common/FormatSubvalueParser';
 import type { CsvSettings } from '../formats/csv/CsvSettings';
 import type { AbstractFormfactorDefinition } from '../formfactors/_common/AbstractFormfactorDefinition';
 import type { FormfactorDefinition } from '../formfactors/_common/FormfactorDefinition';
@@ -358,6 +359,7 @@ export type { UsageCounts };
 export type { UserInterfaceTools };
 export type { UserInterfaceToolsPromptDialogOptions };
 export type { FormatSubvalueParser };
+export type { FormatSubvalueParserMapValuesOptions };
 export type { CsvSettings };
 export type { AbstractFormfactorDefinition };
 export type { FormfactorDefinition };

package/esm/typings/src/execution/createPipelineExecutor/30-executeFormatSubvalues.d.ts

@@ -1,11 +1,18 @@
+import type { PartialDeep, Promisable } from 'type-fest';
 import type { TODO_any } from '../../utils/organization/TODO_any';
+import type { PipelineExecutorResult } from '../PipelineExecutorResult';
 import type { ExecuteAttemptsOptions } from './40-executeAttempts';
 /**
  * @@@
  *
  * @private internal type of `executeFormatSubvalues`
  */
-type ExecuteFormatCellsOptions = ExecuteAttemptsOptions;
+type ExecuteFormatCellsOptions = ExecuteAttemptsOptions & {
+    /**
+     * @@@
+     */
+    readonly onProgress: (newOngoingResult: PartialDeep<PipelineExecutorResult>) => Promisable<void>;
+};
 /**
  * @@@
  *

package/esm/typings/src/formats/_common/FormatSubvalueParser.d.ts

@@ -24,7 +24,17 @@ export type FormatSubvalueParser<TValue extends string, TSettings extends empty_
      * For example, if you have a JSON object and you want to map all values to uppercase
      * Or iterate over all CSV cells @@@
      */
-    mapValues(value: TValue, outputParameterName: string_parameter_name, settings: TSettings, mapCallback: (subvalues: Parameters, index: number) => Promisable<string>): Promise<string>;
+    mapValues(options: FormatSubvalueParserMapValuesOptions<TValue, TSettings>): Promise<string>;
+};
+/**
+ * @@@
+ */
+export type FormatSubvalueParserMapValuesOptions<TValue extends string, TSettings extends empty_object> = {
+    readonly value: TValue;
+    readonly outputParameterName: string_parameter_name;
+    readonly settings: TSettings;
+    mapCallback: (subvalues: Parameters, index: number) => Promisable<TValue>;
+    onProgress(partialResultString: TValue): Promisable<void>;
 };
 /**
  * Note: [👩🏾‍🤝‍🧑🏽]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/markdown-utils",
-    "version": "0.92.0-21",
+    "version": "0.92.0-22",
     "description": "It's time for a paradigm shift. The future of software in plain English, French or Latin",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.92.0-21';
+    const PROMPTBOOK_ENGINE_VERSION = '0.92.0-22';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -4223,7 +4223,8 @@
         subvalueParsers: [
             {
                 subvalueName: 'ROW',
-                async mapValues(value, outputParameterName, settings, mapCallback) {
+                async mapValues(options) {
+                    const { value, outputParameterName, settings, mapCallback, onProgress } = options;
                     const csv = csvParse(value, settings);
                     if (csv.errors.length !== 0) {
                         throw new CsvFormatError(spaceTrim__default["default"]((block) => `
@@ -4239,21 +4240,29 @@
                                 ${block(value)}
                             `));
                     }
-                    const mappedData = await Promise.all(csv.data.map(async (row, index) => {
+                    const mappedData = [];
+                    for (let index = 0; index < csv.data.length; index++) {
+                        const row = csv.data[index];
                         if (row[outputParameterName]) {
                             throw new CsvFormatError(`Can not overwrite existing column "${outputParameterName}" in CSV row`);
                         }
-                        return {
+                        const mappedRow = {
                             ...row,
                             [outputParameterName]: await mapCallback(row, index),
                         };
-                    }));
+                        mappedData.push(mappedRow);
+                        if (onProgress) {
+                            // Note: Report the CSV with all rows mapped so far
+                            await onProgress(papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS }));
+                        }
+                    }
                     return papaparse.unparse(mappedData, { ...settings, ...MANDATORY_CSV_SETTINGS });
                 },
             },
             {
                 subvalueName: 'CELL',
-                async mapValues(value, outputParameterName, settings, mapCallback) {
+                async mapValues(options) {
+                    const { value, settings, mapCallback, onProgress } = options;
                     const csv = csvParse(value, settings);
                     if (csv.errors.length !== 0) {
                         throw new CsvFormatError(spaceTrim__default["default"]((block) => `
@@ -4340,7 +4349,8 @@
         subvalueParsers: [
             {
                 subvalueName: 'LINE',
-                async mapValues(value, outputParameterName, settings, mapCallback) {
+                async mapValues(options) {
+                    const { value, mapCallback, onProgress } = options;
                     const lines = value.split('\n');
                     const mappedLines = await Promise.all(lines.map((lineContent, lineNumber) => 
                     // TODO: [🧠] Maybe option to skip empty line
@@ -5059,7 +5069,7 @@
      * @private internal utility of `createPipelineExecutor`
      */
     async function executeFormatSubvalues(options) {
-        const { task, jokerParameterNames, parameters, priority, csvSettings, pipelineIdentification } = options;
+        const { task, jokerParameterNames, parameters, priority, csvSettings, onProgress, pipelineIdentification } = options;
         if (task.foreach === undefined) {
             return /* not await */ executeAttempts(options);
         }
@@ -5113,21 +5123,32 @@
             formatSettings = csvSettings;
             // <- TODO: [🤹‍♂️] More universal, make simmilar pattern for other formats for example \n vs \r\n in text
         }
-        const resultString = await subvalueParser.mapValues(parameterValue, task.foreach.outputSubparameterName, formatSettings, async (subparameters, index) => {
-            let mappedParameters;
-            // TODO: [🤹‍♂️][🪂] Limit to N concurrent executions
-            // TODO: When done [🐚] Report progress also for each subvalue here
-            try {
-                mappedParameters = mapAvailableToExpectedParameters({
-                    expectedParameters: Object.fromEntries(task.foreach.inputSubparameterNames.map((subparameterName) => [subparameterName, null])),
-                    availableParameters: subparameters,
-                });
-            }
-            catch (error) {
-                if (!(error instanceof PipelineExecutionError)) {
-                    throw error;
+        const resultString = await subvalueParser.mapValues({
+            value: parameterValue,
+            outputParameterName: task.foreach.outputSubparameterName,
+            settings: formatSettings,
+            onProgress(partialResultString) {
+                return onProgress(Object.freeze({
+                    [task.resultingParameterName]: 
+                    // <- Note: [👩‍👩‍👧] No need to detect parameter collision here because pipeline checks logic consistency during construction
+                    partialResultString,
+                }));
+            },
+            async mapCallback(subparameters, index) {
+                let mappedParameters;
+                // TODO: [🤹‍♂️][🪂] Limit to N concurrent executions
+                // TODO: When done [🐚] Report progress also for each subvalue here
+                try {
+                    mappedParameters = mapAvailableToExpectedParameters({
+                        expectedParameters: Object.fromEntries(task.foreach.inputSubparameterNames.map((subparameterName) => [subparameterName, null])),
+                        availableParameters: subparameters,
+                    });
                 }
-                throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
+                catch (error) {
+                    if (!(error instanceof PipelineExecutionError)) {
+                        throw error;
+                    }
+                    throw new PipelineExecutionError(spaceTrim__default["default"]((block) => `
                         ${error.message}
 
                         This is error in FOREACH command
@@ -5136,23 +5157,24 @@
                         ${block(pipelineIdentification)}
                         Subparameter index: ${index}
                     `));
-            }
-            const allSubparameters = {
-                ...parameters,
-                ...mappedParameters,
-            };
-            // Note: [👨‍👨‍👧] Now we can freeze `subparameters` because we are sure that all and only used parameters are defined and are not going to be changed
-            Object.freeze(allSubparameters);
-            const subresultString = await executeAttempts({
-                ...options,
-                priority: priority + index,
-                parameters: allSubparameters,
-                pipelineIdentification: spaceTrim__default["default"]((block) => `
+                }
+                const allSubparameters = {
+                    ...parameters,
+                    ...mappedParameters,
+                };
+                // Note: [👨‍👨‍👧] Now we can freeze `subparameters` because we are sure that all and only used parameters are defined and are not going to be changed
+                Object.freeze(allSubparameters);
+                const subresultString = await executeAttempts({
+                    ...options,
+                    priority: priority + index,
+                    parameters: allSubparameters,
+                    pipelineIdentification: spaceTrim__default["default"]((block) => `
                         ${block(pipelineIdentification)}
                         Subparameter index: ${index}
                     `),
-            });
-            return subresultString;
+                });
+                return subresultString;
+            },
         });
         return resultString;
     }
@@ -5326,11 +5348,6 @@
     async function executeTask(options) {
         const { currentTask, preparedPipeline, parametersToPass, tools, onProgress, $executionReport, pipelineIdentification, maxExecutionAttempts, maxParallelCount, csvSettings, isVerbose, rootDirname, cacheDirname, intermediateFilesStrategy, isAutoInstalled, isNotPreparedWarningSupressed, } = options;
         const priority = preparedPipeline.tasks.length - preparedPipeline.tasks.indexOf(currentTask);
-        await onProgress({
-            outputParameters: {
-                [currentTask.resultingParameterName]: '', // <- TODO: [🧠] What is the best value here?
-            },
-        });
         // Note: Check consistency of used and dependent parameters which was also done in `validatePipeline`, but it’s good to doublecheck
         const usedParameterNames = extractParameterNamesFromTask(currentTask);
         const dependentParameterNames = new Set(currentTask.dependentParameterNames);
@@ -5405,6 +5422,7 @@
             preparedPipeline,
             tools,
             $executionReport,
+            onProgress,
             pipelineIdentification,
             maxExecutionAttempts,
             maxParallelCount,