@taqueria/protocol 0.56.15 → 0.57.8

package/index.js

@@ -193,6 +193,14 @@ var taskSchema = import_zod.z.object({
   options: import_zod.z.array(optionSchema).optional(),
   positionals: import_zod.z.array(positionalArgSchema).optional()
 });
+var pluginSchemaBaseSchema = import_zod.z.object({
+  name: nonEmptyStringSchema,
+  version: versionNumberSchema,
+  schema: versionNumberSchema,
+  alias: aliasSchema,
+  tasks: import_zod.z.array(taskSchema).optional(),
+  postInstall: import_zod.z.string().optional()
+});
 var runtimeDependencySchema = import_zod.z.object({
   name: humanReadableIdentifierSchema,
   path: import_zod.z.string(),
@@ -319,10 +327,23 @@ var metadataConfigSchema = import_zod.z.object({
   homepage: import_zod.z.string().optional()
 });
 var versionV2Schema = import_zod.z.string().regex(/^v2$/);
+var configAccountSchema = import_zod.z.object({
+  balance: currencyAmountV2Schema
+});
 var sandboxAccountSchema = import_zod.z.object({
   type: import_zod.z.string().optional()
 }).passthrough();
 var sandboxAccountsSchema = import_zod.z.record(sandboxAccountSchema);
+var configEnvironmentFileV2Schema = import_zod.z.object({
+  type: import_zod.z.string().optional(),
+  accounts: sandboxAccountsSchema.optional(),
+  accountDefault: import_zod.z.any().optional(),
+  contracts: import_zod.z.record(
+    import_zod.z.object({
+      address: import_zod.z.string().optional()
+    })
+  ).optional()
+}).passthrough();
 var networkAccountConfigSchema = import_zod.z.object({
   publicKey: nonEmptyStringSchema.optional(),
   publicKeyHash: publicKeyHashSchema.optional(),
@@ -334,39 +355,28 @@ var sandboxAccountConfigSchema = import_zod.z.object({
   publicKeyHash: publicKeyHashSchema,
   secretKey: nonEmptyStringSchema
 });
+var sandboxConfigSchema = import_zod.z.object({
+  label: nonEmptyStringSchema,
+  rpcUrl: urlSchema,
+  protocol: economicalProtocolHashSchema.optional(),
+  plugin: verbSchema.optional(),
+  accounts: import_zod.z.record(import_zod.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
+  tzkt: tzKtConfigSchema.optional(),
+  annotations: import_zod.z.record(import_zod.z.unknown()).optional()
+});
 var scaffoldConfigSchema = import_zod.z.object({
   postInit: import_zod.z.string().optional()
 });
-var pluginSchemaBaseSchema = import_zod.z.object({
-  name: nonEmptyStringSchema,
-  version: versionNumberSchema,
-  schema: versionNumberSchema,
-  alias: aliasSchema,
-  tasks: import_zod.z.array(taskSchema).optional(),
-  postInstall: import_zod.z.string().optional()
-});
 var persistentStateSchema = import_zod.z.object({
   operations: import_zod.z.record(persistedOperationSchema),
   tasks: import_zod.z.record(persistedTaskSchema)
 });
-var configAccountSchema = import_zod.z.object({
-  balance: currencyAmountV2Schema
-});
 var networkConfigSchema = import_zod.z.object({
   label: humanReadableIdentifierSchema,
   rpcUrl: urlSchema,
   accounts: import_zod.z.record(networkAccountConfigSchema).optional(),
   faucet: faucetSchema.optional()
 });
-var sandboxConfigSchema = import_zod.z.object({
-  label: nonEmptyStringSchema,
-  rpcUrl: urlSchema,
-  protocol: economicalProtocolHashSchema.optional(),
-  plugin: verbSchema.optional(),
-  accounts: import_zod.z.record(import_zod.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
-  tzkt: tzKtConfigSchema.optional(),
-  annotations: import_zod.z.record(import_zod.z.unknown()).optional()
-});
 var configFileV1Schema = import_zod.z.object({
   language: humanLanguageSchema.optional(),
   plugins: import_zod.z.array(installedPluginSchema).optional(),
@@ -379,28 +389,6 @@ var configFileV1Schema = import_zod.z.object({
   contracts: import_zod.z.record(contractSchema).optional(),
   metadata: metadataConfigSchema.optional()
 });
-var configEnvironmentFileV2Schema = import_zod.z.object({
-  type: import_zod.z.string().optional(),
-  accounts: sandboxAccountsSchema.optional(),
-  accountDefault: import_zod.z.any().optional(),
-  contracts: import_zod.z.record(
-    import_zod.z.object({
-      address: import_zod.z.string().optional()
-    })
-  ).optional()
-}).passthrough();
-var configSchema = import_zod.z.object({
-  language: humanLanguageSchema.optional(),
-  metadata: metadataConfigSchema.optional(),
-  artifactsDir: configArtifactsDirSchema.optional(),
-  contractsDir: configContractsDirSchema.optional(),
-  contracts: import_zod.z.record(contractSchema).optional(),
-  plugins: import_zod.z.array(installedPluginSchema).optional(),
-  accounts: import_zod.z.record(tzSchema).optional(),
-  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])),
-  network: import_zod.z.record(networkConfigSchema).optional(),
-  sandbox: import_zod.z.record(sandboxConfigSchema).optional()
-});
 var configFileV2Schema = import_zod.z.object({
   version: versionV2Schema,
   language: humanLanguageSchema.optional(),
@@ -413,6 +401,18 @@ var configFileV2Schema = import_zod.z.object({
   environments: import_zod.z.record(configEnvironmentFileV2Schema).optional(),
   plugins: import_zod.z.array(installedPluginSchema).optional()
 });
+var configSchema = import_zod.z.object({
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  contracts: import_zod.z.record(contractSchema).optional(),
+  plugins: import_zod.z.array(installedPluginSchema).optional(),
+  accounts: import_zod.z.record(tzSchema).optional(),
+  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])),
+  network: import_zod.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod.z.record(sandboxConfigSchema).optional()
+});
 var parsedConfigSchema = configSchema.omit({ sandbox: true }).extend(
   {
     sandbox: import_zod.z.record(import_zod.z.union([sandboxConfigSchema, nonEmptyStringSchema]))
@@ -431,11 +431,6 @@ var requestArgsSchema = sanitizedArgsSchema.omit({ quickstart: true }).extend(
     config: loadedConfigSchema
   }
 ).passthrough();
-var proxyTaskArgsSchema = requestArgsSchema.extend(
-  {
-    task: nonEmptyStringSchema
-  }
-).passthrough();
 var proxyTemplateArgsSchema = requestArgsSchema.extend(
   {
     template: nonEmptyStringSchema
@@ -472,12 +467,6 @@ var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
     handler: import_zod.z.string()
   }
 );
-var pluginInfoSchema = pluginSchemaBaseSchema.extend(
-  {
-    operations: import_zod.z.array(parsedOperationSchema).optional(),
-    templates: import_zod.z.array(parsedTemplateSchema).optional()
-  }
-);
 var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
   {
     operations: import_zod.z.array(operationSchema).optional(),
@@ -487,6 +476,17 @@ var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
     installRuntimeDependencies: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginDependenciesResponseSchema)).optional()
   }
 );
+var proxyTaskArgsSchema = requestArgsSchema.extend(
+  {
+    task: nonEmptyStringSchema
+  }
+).passthrough();
+var pluginInfoSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod.z.array(parsedOperationSchema).optional(),
+    templates: import_zod.z.array(parsedTemplateSchema).optional()
+  }
+);
 var ephemeralStateSchema = import_zod.z.object({
   build: import_zod.z.string(),
   configHash: import_zod.z.string(),
@@ -2904,7 +2904,6 @@ __export(EphemeralState_exports, {
   of: () => of48,
   schemas: () => schemas48
 });
-var import_protocol = require("@taqueria/protocol");
 var import_fluture48 = require("fluture");
 var import_zod50 = require("zod");
 var eager = (f) => (0, import_fluture48.promise)(
@@ -2912,20 +2911,20 @@ var eager = (f) => (0, import_fluture48.promise)(
 );
 var taskToPluginMap = import_zod50.z.record(
   import_zod50.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.Task.schemas.schema
+    InstalledPlugin_exports.schemas.schema,
+    Task_exports.schemas.schema
   ], { description: "Task/Plugin Mapping" })
 );
 var operationToPluginMap = import_zod50.z.record(
   import_zod50.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.ParsedOperation.schemas.schema
+    InstalledPlugin_exports.schemas.schema,
+    ParsedOperation_exports.schemas.schema
   ], { description: "Operation/Plugin Mapping" })
 );
 var templateToPluginMap = import_zod50.z.record(
   import_zod50.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.ParsedTemplate.schemas.schema
+    InstalledPlugin_exports.schemas.schema,
+    ParsedTemplate_exports.schemas.schema
   ])
 );
 var rawSchema48 = import_zod50.z.object({
@@ -2934,7 +2933,7 @@ var rawSchema48 = import_zod50.z.object({
   tasks: taskToPluginMap,
   operations: operationToPluginMap,
   templates: templateToPluginMap,
-  plugins: import_zod50.z.array(import_protocol.PluginInfo.schemas.schema, { description: "cache.plugins" })
+  plugins: import_zod50.z.array(PluginInfo_exports.schemas.schema, { description: "cache.plugins" })
 }).describe("Ephemeral State");
 var { schemas: generatedSchemas2, factory: factory3 } = Base_default({
   rawSchema: rawSchema48,
@@ -3011,17 +3010,17 @@ var mapTasksToPlugins = (config, pluginInfo, i18n) => {
       async (retval, pluginInfo2) => !pluginInfo2.tasks ? Promise.resolve({}) : await pluginInfo2.tasks.reduce(
         async (retval2, { task, hidden }) => {
           if (isComposite(task, taskCounts)) {
-            const command = await eager(import_protocol.Command.make(task));
-            const compositeTask = await eager(import_protocol.Task.make({
+            const command = await eager(Command_exports.make(task));
+            const compositeTask = await eager(Task_exports.make({
               task,
               command,
-              description: await eager(import_protocol.NonEmptyString.make(i18n.__("providedByMany"))),
+              description: await eager(NonEmptyString_exports.make(i18n.__("providedByMany"))),
               hidden,
               options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
+                await eager(Option_exports.make({
+                  flag: await eager(Verb_exports.make("plugin")),
                   description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this task")
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this task")
                   ),
                   choices: toChoices(taskCounts[task]),
                   required: true
@@ -3047,16 +3046,16 @@ var mapOperationsToPlugins = (config, pluginInfo, i18n) => {
       async (retval, pluginInfo2) => !pluginInfo2.operations ? Promise.resolve({}) : await pluginInfo2.operations.reduce(
         async (retval2, { operation }) => {
           if (isComposite(operation, opCounts)) {
-            const command = await eager(import_protocol.Command.make(operation));
-            const compositeOp = await eager(import_protocol.ParsedOperation.make({
+            const command = await eager(Command_exports.make(operation));
+            const compositeOp = await eager(ParsedOperation_exports.make({
               operation,
               command,
-              description: await eager(import_protocol.NonEmptyString.make(i18n.__("providedByMany"))),
+              description: await eager(NonEmptyString_exports.make(i18n.__("providedByMany"))),
               options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
+                await eager(Option_exports.make({
+                  flag: await eager(Verb_exports.make("plugin")),
                   description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this operation")
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this operation")
                   ),
                   choices: toChoices(opCounts[operation]),
                   required: true
@@ -3081,24 +3080,24 @@ var mapTemplatesToPlugins = (config, pluginInfo, i18n) => {
       async (retval, pluginInfo2) => !pluginInfo2.templates ? Promise.resolve({}) : await pluginInfo2.templates.reduce(
         async (retval2, { template, hidden }) => {
           if (isComposite(template, tmplCounts)) {
-            const command = await eager(import_protocol.Command.make(template));
-            const description = await eager(import_protocol.NonEmptyString.of(i18n.__("providedByMany")));
-            const compositeTmpl = await eager(import_protocol.ParsedTemplate.make({
+            const command = await eager(Command_exports.make(template));
+            const description = await eager(NonEmptyString_exports.of(i18n.__("providedByMany")));
+            const compositeTmpl = await eager(ParsedTemplate_exports.make({
               template,
               command,
               description,
               options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
+                await eager(Option_exports.make({
+                  flag: await eager(Verb_exports.make("plugin")),
                   description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this task")
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this task")
                   ),
                   choices: toChoices(tmplCounts[template]),
                   required: true
                 }))
               ],
               handler: "proxy",
-              encoding: import_protocol.PluginResponseEncoding.create("none")
+              encoding: PluginResponseEncoding_exports.create("none")
             }));
             return { ...await retval2, [template]: compositeTmpl };
           }