@algorandfoundation/algokit-client-generator 2.6.0 → 2.6.1-beta.1

package/client/{call-factory.js → call-factory.mjs}

@@ -1,46 +1,20 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callFactory = void 0;
-const writer_1 = require("../output/writer");
-const sanitization_1 = require("../util/sanitization");
-const algokit = __importStar(require("@algorandfoundation/algokit-utils"));
-const get_call_config_summary_1 = require("./helpers/get-call-config-summary");
-const deploy_types_1 = require("./deploy-types");
+import { jsDoc, IncIndent, DecIndent, DecIndentAndCloseBlock, NewLine } from '../output/writer.mjs';
+import { makeSafeMethodIdentifier, isSafeVariableIdentifier, makeSafePropertyIdentifier } from '../util/sanitization.mjs';
+import * as algokit from '@algorandfoundation/algokit-utils';
+import { BARE_CALL } from './helpers/get-call-config-summary.mjs';
+import { getCreateOnCompleteOptions } from './deploy-types.mjs';
+
 function* callFactory(ctx) {
-    yield* (0, writer_1.jsDoc)('Exposes methods for constructing all available smart contract calls');
+    yield* jsDoc('Exposes methods for constructing all available smart contract calls');
     yield `export abstract class ${ctx.name}CallFactory {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield* opMethods(ctx);
     for (const method of ctx.app.contract.methods) {
         yield* callFactoryMethod(ctx, method);
     }
-    yield writer_1.DecIndent;
+    yield DecIndent;
     yield '}';
 }
-exports.callFactory = callFactory;
 function* opMethods(ctx) {
     const { app, callConfig } = ctx;
     yield* operationMethod(ctx, `Constructs a create call for the ${app.contract.name} smart contract`, callConfig.createMethods, 'create', true);
@@ -51,15 +25,15 @@ function* opMethods(ctx) {
 }
 function* operationMethod({ app, methodSignatureToUniqueName }, description, methods, verb, includeCompilation) {
     if (methods.length) {
-        yield* (0, writer_1.jsDoc)(`Gets available ${verb} call factories`);
+        yield* jsDoc(`Gets available ${verb} call factories`);
         yield `static get ${verb}() {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         yield `return {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         for (const methodSig of methods) {
-            const onComplete = verb === 'create' ? (0, deploy_types_1.getCreateOnCompleteOptions)(methodSig, app) : undefined;
-            if (methodSig === get_call_config_summary_1.BARE_CALL) {
-                yield* (0, writer_1.jsDoc)({
+            const onComplete = verb === 'create' ? getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === BARE_CALL) {
+                yield* jsDoc({
                     description: `${description} using a bare call`,
                     params: {
                         params: `Any parameters for the call`,
@@ -69,13 +43,13 @@ function* operationMethod({ app, methodSignatureToUniqueName }, description, met
                 yield* factoryMethod({
                     isNested: true,
                     name: 'bare',
-                    paramTypes: `BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? ' = {}' : ''}`,
+                    paramTypes: `BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}`,
                 });
             }
             else {
                 const method = app.contract.methods.find((m) => algokit.getABIMethodSignature(m) === methodSig);
                 const uniqueName = methodSignatureToUniqueName[methodSig];
-                yield* (0, writer_1.jsDoc)({
+                yield* jsDoc({
                     description: `${description} using the ${methodSig} ABI method`,
                     params: {
                         args: `Any args for the contract call`,
@@ -85,23 +59,23 @@ function* operationMethod({ app, methodSignatureToUniqueName }, description, met
                 });
                 yield* factoryMethod({
                     isNested: true,
-                    name: (0, sanitization_1.makeSafeMethodIdentifier)(uniqueName),
+                    name: makeSafeMethodIdentifier(uniqueName),
                     signature: methodSig,
                     args: method.args,
-                    paramTypes: `AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? ' = {}' : ''}`,
+                    paramTypes: `AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}`,
                 });
             }
         }
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
 }
 function* callFactoryMethod({ methodSignatureToUniqueName, callConfig }, method) {
     const methodSignature = algokit.getABIMethodSignature(method);
     if (!callConfig.callMethods.includes(methodSignature))
         return;
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: `Constructs a no op call for the ${methodSignature} ABI method`,
         abiDescription: method.desc,
         params: {
@@ -112,7 +86,7 @@ function* callFactoryMethod({ methodSignatureToUniqueName, callConfig }, method)
     });
     yield* factoryMethod({
         isNested: false,
-        name: (0, sanitization_1.makeSafeMethodIdentifier)(methodSignatureToUniqueName[methodSignature]),
+        name: makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]),
         signature: methodSignature,
         args: method.args,
         paramTypes: 'AppClientCallCoreParams & CoreAppCallArgs',
@@ -120,13 +94,13 @@ function* callFactoryMethod({ methodSignatureToUniqueName, callConfig }, method)
 }
 function* factoryMethod({ isNested, name, signature, args, paramTypes, }) {
     yield `${isNested ? '' : 'static '}${name}(${signature === undefined ? '' : `args: MethodArgs<'${signature}'>, `}params: ${paramTypes}) {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `return {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     if (signature) {
         yield `method: '${signature}' as const,`;
         yield `methodArgs: Array.isArray(args) ? args : [${args
-            .map((a) => ((0, sanitization_1.isSafeVariableIdentifier)(a.name) ? `args.${a.name}` : `args['${(0, sanitization_1.makeSafePropertyIdentifier)(a.name)}']`))
+            .map((a) => (isSafeVariableIdentifier(a.name) ? `args.${a.name}` : `args['${makeSafePropertyIdentifier(a.name)}']`))
             .join(', ')}],`;
     }
     else {
@@ -134,9 +108,10 @@ function* factoryMethod({ isNested, name, signature, args, paramTypes, }) {
         yield `methodArgs: undefined,`;
     }
     yield '...params,';
-    yield writer_1.DecIndent;
+    yield DecIndent;
     yield '}';
-    yield writer_1.DecIndent;
+    yield DecIndent;
     yield `}${isNested ? ',' : ''}`;
 }
-//# sourceMappingURL=call-factory.js.map
+
+export { callFactory };

package/client/deploy-types.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var writer = require('../output/writer.cjs');
+var sanitization = require('../util/sanitization.cjs');
+var getCallConfigSummary = require('./helpers/get-call-config-summary.cjs');
+var utilityTypes = require('./utility-types.cjs');
+
+function getCreateOnCompleteOptions(method, app) {
+    const callConfig = method === getCallConfigSummary.BARE_CALL ? app.bare_call_config : app.hints?.[method]?.call_config;
+    const hasNoOp = callConfig?.no_op === 'ALL' || callConfig?.no_op === 'CREATE';
+    const onCompleteType = callConfig
+        ? `(${Object.entries(callConfig)
+            .filter(([_, value]) => value === 'ALL' || value === 'CREATE')
+            .map(([oc]) => utilityTypes.OnCompleteCodeMap[oc])
+            .join(' | ')})`
+        : {};
+    return {
+        type: onCompleteType,
+        isOptional: hasNoOp,
+    };
+}
+function* deployTypes({ app, callConfig }) {
+    const name = sanitization.makeSafeTypeIdentifier(app.contract.name);
+    if (callConfig.createMethods.length > 0) {
+        yield* writer.jsDoc(`A factory for available 'create' calls`);
+        yield `export type ${name}CreateCalls = (typeof ${name}CallFactory)['create']`;
+        yield* writer.jsDoc('Defines supported create methods for this smart contract');
+        yield `export type ${name}CreateCallParams =`;
+        yield writer.IncIndent;
+        for (const method of callConfig.createMethods) {
+            const onComplete = getCreateOnCompleteOptions(method, app);
+            if (method === getCallConfigSummary.BARE_CALL) {
+                yield `| (TypedCallParams<undefined> & ${onComplete.type})`;
+            }
+            else {
+                yield `| (TypedCallParams<'${method}'> & ${onComplete.type})`;
+            }
+        }
+        yield writer.DecIndent;
+    }
+    if (callConfig.updateMethods.length > 0) {
+        yield* writer.jsDoc(`A factory for available 'update' calls`);
+        yield `export type ${name}UpdateCalls = (typeof ${name}CallFactory)['update']`;
+        yield* writer.jsDoc('Defines supported update methods for this smart contract');
+        yield `export type ${name}UpdateCallParams =`;
+        yield writer.IncIndent;
+        for (const method of callConfig.updateMethods) {
+            if (method === getCallConfigSummary.BARE_CALL) {
+                yield `| TypedCallParams<undefined>`;
+            }
+            else {
+                yield `| TypedCallParams<'${method}'>`;
+            }
+        }
+        yield writer.DecIndent;
+    }
+    if (callConfig.deleteMethods.length > 0) {
+        yield* writer.jsDoc(`A factory for available 'delete' calls`);
+        yield `export type ${name}DeleteCalls = (typeof ${name}CallFactory)['delete']`;
+        yield* writer.jsDoc('Defines supported delete methods for this smart contract');
+        yield `export type ${name}DeleteCallParams =`;
+        yield writer.IncIndent;
+        for (const method of callConfig.deleteMethods) {
+            if (method === getCallConfigSummary.BARE_CALL) {
+                yield `| TypedCallParams<undefined>`;
+            }
+            else {
+                yield `| TypedCallParams<'${method}'>`;
+            }
+        }
+        yield writer.DecIndent;
+    }
+    yield* writer.jsDoc('Defines arguments required for the deploy method.');
+    yield `export type ${name}DeployArgs = {`;
+    yield writer.IncIndent;
+    yield `deployTimeParams?: TealTemplateParams`;
+    if (callConfig.createMethods.length) {
+        yield* writer.jsDoc('A delegate which takes a create call factory and returns the create call params for this smart contract');
+        yield `createCall?: (callFactory: ${name}CreateCalls) => ${name}CreateCallParams`;
+    }
+    if (callConfig.updateMethods.length) {
+        yield* writer.jsDoc('A delegate which takes a update call factory and returns the update call params for this smart contract');
+        yield `updateCall?: (callFactory: ${name}UpdateCalls) => ${name}UpdateCallParams`;
+    }
+    if (callConfig.deleteMethods.length) {
+        yield* writer.jsDoc('A delegate which takes a delete call factory and returns the delete call params for this smart contract');
+        yield `deleteCall?: (callFactory: ${name}DeleteCalls) => ${name}DeleteCallParams`;
+    }
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.NewLine;
+}
+
+exports.deployTypes = deployTypes;
+exports.getCreateOnCompleteOptions = getCreateOnCompleteOptions;

package/client/deploy-types.d.ts

@@ -7,4 +7,3 @@ export declare function getCreateOnCompleteOptions(method: MethodIdentifier, app
     isOptional: boolean;
 };
 export declare function deployTypes({ app, callConfig }: GeneratorContext): DocumentParts;
-//# sourceMappingURL=deploy-types.d.ts.map

package/client/deploy-types.mjs

@@ -0,0 +1,91 @@
+import { jsDoc, IncIndent, DecIndent, DecIndentAndCloseBlock, NewLine } from '../output/writer.mjs';
+import { makeSafeTypeIdentifier } from '../util/sanitization.mjs';
+import { BARE_CALL } from './helpers/get-call-config-summary.mjs';
+import { OnCompleteCodeMap } from './utility-types.mjs';
+
+function getCreateOnCompleteOptions(method, app) {
+    const callConfig = method === BARE_CALL ? app.bare_call_config : app.hints?.[method]?.call_config;
+    const hasNoOp = callConfig?.no_op === 'ALL' || callConfig?.no_op === 'CREATE';
+    const onCompleteType = callConfig
+        ? `(${Object.entries(callConfig)
+            .filter(([_, value]) => value === 'ALL' || value === 'CREATE')
+            .map(([oc]) => OnCompleteCodeMap[oc])
+            .join(' | ')})`
+        : {};
+    return {
+        type: onCompleteType,
+        isOptional: hasNoOp,
+    };
+}
+function* deployTypes({ app, callConfig }) {
+    const name = makeSafeTypeIdentifier(app.contract.name);
+    if (callConfig.createMethods.length > 0) {
+        yield* jsDoc(`A factory for available 'create' calls`);
+        yield `export type ${name}CreateCalls = (typeof ${name}CallFactory)['create']`;
+        yield* jsDoc('Defines supported create methods for this smart contract');
+        yield `export type ${name}CreateCallParams =`;
+        yield IncIndent;
+        for (const method of callConfig.createMethods) {
+            const onComplete = getCreateOnCompleteOptions(method, app);
+            if (method === BARE_CALL) {
+                yield `| (TypedCallParams<undefined> & ${onComplete.type})`;
+            }
+            else {
+                yield `| (TypedCallParams<'${method}'> & ${onComplete.type})`;
+            }
+        }
+        yield DecIndent;
+    }
+    if (callConfig.updateMethods.length > 0) {
+        yield* jsDoc(`A factory for available 'update' calls`);
+        yield `export type ${name}UpdateCalls = (typeof ${name}CallFactory)['update']`;
+        yield* jsDoc('Defines supported update methods for this smart contract');
+        yield `export type ${name}UpdateCallParams =`;
+        yield IncIndent;
+        for (const method of callConfig.updateMethods) {
+            if (method === BARE_CALL) {
+                yield `| TypedCallParams<undefined>`;
+            }
+            else {
+                yield `| TypedCallParams<'${method}'>`;
+            }
+        }
+        yield DecIndent;
+    }
+    if (callConfig.deleteMethods.length > 0) {
+        yield* jsDoc(`A factory for available 'delete' calls`);
+        yield `export type ${name}DeleteCalls = (typeof ${name}CallFactory)['delete']`;
+        yield* jsDoc('Defines supported delete methods for this smart contract');
+        yield `export type ${name}DeleteCallParams =`;
+        yield IncIndent;
+        for (const method of callConfig.deleteMethods) {
+            if (method === BARE_CALL) {
+                yield `| TypedCallParams<undefined>`;
+            }
+            else {
+                yield `| TypedCallParams<'${method}'>`;
+            }
+        }
+        yield DecIndent;
+    }
+    yield* jsDoc('Defines arguments required for the deploy method.');
+    yield `export type ${name}DeployArgs = {`;
+    yield IncIndent;
+    yield `deployTimeParams?: TealTemplateParams`;
+    if (callConfig.createMethods.length) {
+        yield* jsDoc('A delegate which takes a create call factory and returns the create call params for this smart contract');
+        yield `createCall?: (callFactory: ${name}CreateCalls) => ${name}CreateCallParams`;
+    }
+    if (callConfig.updateMethods.length) {
+        yield* jsDoc('A delegate which takes a update call factory and returns the update call params for this smart contract');
+        yield `updateCall?: (callFactory: ${name}UpdateCalls) => ${name}UpdateCallParams`;
+    }
+    if (callConfig.deleteMethods.length) {
+        yield* jsDoc('A delegate which takes a delete call factory and returns the delete call params for this smart contract');
+        yield `deleteCall?: (callFactory: ${name}DeleteCalls) => ${name}DeleteCallParams`;
+    }
+    yield DecIndentAndCloseBlock;
+    yield NewLine;
+}
+
+export { deployTypes, getCreateOnCompleteOptions };

package/client/generate.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var writer = require('../output/writer.cjs');
+var callFactory = require('./call-factory.cjs');
+var callClient = require('./call-client.cjs');
+var deployTypes = require('./deploy-types.cjs');
+var utilityTypes = require('./utility-types.cjs');
+var imports = require('./imports.cjs');
+var generatorContext = require('./generator-context.cjs');
+var appTypes = require('./app-types.cjs');
+var callComposerTypes = require('./call-composer-types.cjs');
+
+function* generate(app) {
+    const ctx = generatorContext.createGeneratorContext(app);
+    yield `/* eslint-disable */`;
+    yield `/**`;
+    yield ` * This file was automatically generated by @algorandfoundation/algokit-client-generator.`;
+    yield ` * DO NOT MODIFY IT BY HAND.`;
+    yield ` * requires: @algorandfoundation/algokit-utils: ^2`;
+    yield ` */`;
+    yield* imports.imports();
+    yield* writer.inline('export const APP_SPEC: AppSpec = ', JSON.stringify(app, undefined, 2));
+    yield writer.NewLine;
+    yield* utilityTypes.utilityTypes();
+    yield writer.NewLine;
+    yield* appTypes.appTypes(ctx);
+    yield* deployTypes.deployTypes(ctx);
+    yield writer.NewLine;
+    // Write a call factory
+    yield* callFactory.callFactory(ctx);
+    yield writer.NewLine;
+    // Write a client
+    yield* callClient.callClient(ctx);
+    yield* callComposerTypes.callComposerType(ctx);
+}
+
+exports.generate = generate;

package/client/generate.d.ts

@@ -1,4 +1,3 @@
 import { DocumentParts } from '../output/writer';
 import { AlgoAppSpec } from '../schema/application';
 export declare function generate(app: AlgoAppSpec): DocumentParts;
-//# sourceMappingURL=generate.d.ts.map

package/client/generate.mjs

@@ -0,0 +1,35 @@
+import { inline, NewLine } from '../output/writer.mjs';
+import { callFactory } from './call-factory.mjs';
+import { callClient } from './call-client.mjs';
+import { deployTypes } from './deploy-types.mjs';
+import { utilityTypes } from './utility-types.mjs';
+import { imports } from './imports.mjs';
+import { createGeneratorContext } from './generator-context.mjs';
+import { appTypes } from './app-types.mjs';
+import { callComposerType } from './call-composer-types.mjs';
+
+function* generate(app) {
+    const ctx = createGeneratorContext(app);
+    yield `/* eslint-disable */`;
+    yield `/**`;
+    yield ` * This file was automatically generated by @algorandfoundation/algokit-client-generator.`;
+    yield ` * DO NOT MODIFY IT BY HAND.`;
+    yield ` * requires: @algorandfoundation/algokit-utils: ^2`;
+    yield ` */`;
+    yield* imports();
+    yield* inline('export const APP_SPEC: AppSpec = ', JSON.stringify(app, undefined, 2));
+    yield NewLine;
+    yield* utilityTypes();
+    yield NewLine;
+    yield* appTypes(ctx);
+    yield* deployTypes(ctx);
+    yield NewLine;
+    // Write a call factory
+    yield* callFactory(ctx);
+    yield NewLine;
+    // Write a client
+    yield* callClient(ctx);
+    yield* callComposerType(ctx);
+}
+
+export { generate };

package/client/generator-context.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var getCallConfigSummary = require('./helpers/get-call-config-summary.cjs');
+var sanitization = require('../util/sanitization.cjs');
+var algokit = require('@algorandfoundation/algokit-utils');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var algokit__namespace = /*#__PURE__*/_interopNamespaceDefault(algokit);
+
+const createGeneratorContext = (app) => ({
+    app,
+    name: sanitization.makeSafeTypeIdentifier(app.contract.name),
+    callConfig: getCallConfigSummary.getCallConfigSummary(app),
+    methodSignatureToUniqueName: app.contract.methods.reduce((acc, cur) => {
+        const signature = algokit__namespace.getABIMethodSignature(cur);
+        acc[signature] = app.contract.methods.some((m) => m.name === cur.name && m !== cur) ? signature : cur.name;
+        return acc;
+    }, {}),
+});
+
+exports.createGeneratorContext = createGeneratorContext;

package/client/generator-context.d.ts

@@ -12,4 +12,3 @@ export declare const createGeneratorContext: (app: AlgoAppSpec) => {
     callConfig: CallConfigSummary;
     methodSignatureToUniqueName: Record<string, string>;
 };
-//# sourceMappingURL=generator-context.d.ts.map

package/client/generator-context.mjs

@@ -0,0 +1,16 @@
+import { getCallConfigSummary } from './helpers/get-call-config-summary.mjs';
+import { makeSafeTypeIdentifier } from '../util/sanitization.mjs';
+import * as algokit from '@algorandfoundation/algokit-utils';
+
+const createGeneratorContext = (app) => ({
+    app,
+    name: makeSafeTypeIdentifier(app.contract.name),
+    callConfig: getCallConfigSummary(app),
+    methodSignatureToUniqueName: app.contract.methods.reduce((acc, cur) => {
+        const signature = algokit.getABIMethodSignature(cur);
+        acc[signature] = app.contract.methods.some((m) => m.name === cur.name && m !== cur) ? signature : cur.name;
+        return acc;
+    }, {}),
+});
+
+export { createGeneratorContext };

package/client/helpers/{get-call-config-summary.js → get-call-config-summary.cjs}

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCreateOnComplete = exports.getCallConfigSummary = exports.BARE_CALL = void 0;
-const change_case_1 = require("change-case");
-exports.BARE_CALL = Symbol('bare');
+'use strict';
+
+const BARE_CALL = Symbol('bare');
 const getCallConfigSummary = (app) => {
     const result = {
         createMethods: [],
@@ -13,7 +11,7 @@ const getCallConfigSummary = (app) => {
         closeOutMethods: [],
     };
     if (app.bare_call_config) {
-        addToConfig(result, exports.BARE_CALL, app.bare_call_config);
+        addToConfig(result, BARE_CALL, app.bare_call_config);
     }
     if (app.hints) {
         for (const [method, hints] of Object.entries(app.hints)) {
@@ -24,24 +22,6 @@ const getCallConfigSummary = (app) => {
     }
     return result;
 };
-exports.getCallConfigSummary = getCallConfigSummary;
-const getCreateOnComplete = (app, method) => {
-    var _a, _b;
-    const callConfig = method === exports.BARE_CALL ? app.bare_call_config : (_b = (_a = app.hints) === null || _a === void 0 ? void 0 : _a[method]) === null || _b === void 0 ? void 0 : _b.call_config;
-    if (!callConfig) {
-        return '';
-    }
-    const hasNoOp = callConfig.no_op === 'ALL' || callConfig.no_op === 'CREATE';
-    return `{ onCompleteAction${hasNoOp ? '?' : ''}: ${getCreateOnCompleteTypes(callConfig)} }`;
-};
-exports.getCreateOnComplete = getCreateOnComplete;
-const getCreateOnCompleteTypes = (config) => {
-    return Object.keys(config)
-        .map((oc) => oc)
-        .filter((oc) => config[oc] === 'ALL' || config[oc] === 'CREATE')
-        .map((oc) => `'${oc}' | OnApplicationComplete.${(0, change_case_1.pascalCase)(oc)}OC`)
-        .join(' | ');
-};
 const addToConfig = (result, method, config) => {
     if (hasCall(config.no_op)) {
         result.callMethods.push(method);
@@ -72,4 +52,6 @@ const hasCall = (config) => {
 const hasCreate = (config) => {
     return config === 'CREATE' || config === 'ALL';
 };
-//# sourceMappingURL=get-call-config-summary.js.map
+
+exports.BARE_CALL = BARE_CALL;
+exports.getCallConfigSummary = getCallConfigSummary;

package/client/helpers/get-call-config-summary.d.ts

@@ -1,4 +1,4 @@
-import { AlgoAppSpec } from '../../schema/application';
+import { AlgoAppSpec } from '../../schema/application.js';
 export declare const BARE_CALL: unique symbol;
 export type MethodIdentifier = string | typeof BARE_CALL;
 export type MethodList = Array<MethodIdentifier>;
@@ -12,4 +12,3 @@ export type CallConfigSummary = {
 };
 export declare const getCallConfigSummary: (app: AlgoAppSpec) => CallConfigSummary;
 export declare const getCreateOnComplete: (app: AlgoAppSpec, method: MethodIdentifier) => string;
-//# sourceMappingURL=get-call-config-summary.d.ts.map

package/client/helpers/get-call-config-summary.mjs

@@ -0,0 +1,54 @@
+const BARE_CALL = Symbol('bare');
+const getCallConfigSummary = (app) => {
+    const result = {
+        createMethods: [],
+        callMethods: [],
+        deleteMethods: [],
+        updateMethods: [],
+        optInMethods: [],
+        closeOutMethods: [],
+    };
+    if (app.bare_call_config) {
+        addToConfig(result, BARE_CALL, app.bare_call_config);
+    }
+    if (app.hints) {
+        for (const [method, hints] of Object.entries(app.hints)) {
+            if (hints.call_config) {
+                addToConfig(result, method, hints.call_config);
+            }
+        }
+    }
+    return result;
+};
+const addToConfig = (result, method, config) => {
+    if (hasCall(config.no_op)) {
+        result.callMethods.push(method);
+    }
+    if (hasCreate(config.no_op) ||
+        hasCreate(config.opt_in) ||
+        hasCreate(config.close_out) ||
+        hasCreate(config.update_application) ||
+        hasCreate(config.delete_application)) {
+        result.createMethods.push(method);
+    }
+    if (hasCall(config.delete_application)) {
+        result.deleteMethods.push(method);
+    }
+    if (hasCall(config.update_application)) {
+        result.updateMethods.push(method);
+    }
+    if (hasCall(config.opt_in)) {
+        result.optInMethods.push(method);
+    }
+    if (hasCall(config.close_out)) {
+        result.closeOutMethods.push(method);
+    }
+};
+const hasCall = (config) => {
+    return config === 'CALL' || config === 'ALL';
+};
+const hasCreate = (config) => {
+    return config === 'CREATE' || config === 'ALL';
+};
+
+export { BARE_CALL, getCallConfigSummary };