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

package/output/writer.mjs

@@ -0,0 +1,139 @@
+const IncIndent = Symbol('Increase Indent');
+const DecIndent = Symbol('Decrease Indent');
+const DecIndentAndCloseBlock = Symbol('Decrease Indent and write a closing brace');
+const NewLineMode = Symbol('New Line Mode');
+const RestoreLineMode = Symbol('Restore Line Mode');
+const PropertyDelimiter = Symbol('Property Delimiter');
+const InlineMode = Symbol('Inline Mode');
+const NewLine = Symbol('New Line');
+function writeDocumentPartsToStream(document, stream, options = {}) {
+    const writer = {
+        _last: '',
+        write(val) {
+            this._last = val;
+            stream.write(val);
+        },
+        get last() {
+            return this._last;
+        },
+    };
+    writeDocumentPartsTo(document, options, writer);
+}
+function writeDocumentPartsToString(document, options = {}) {
+    const writer = {
+        result: [],
+        _last: '',
+        write(val) {
+            this._last = val;
+            this.result.push(val);
+        },
+        get last() {
+            return this._last;
+        },
+        toString() {
+            return this.result.join('');
+        },
+    };
+    writeDocumentPartsTo(document, options, writer);
+    return writer.toString();
+}
+function* inline(...parts) {
+    yield InlineMode;
+    for (const part of parts) {
+        if (typeof part === 'string' || typeof part === 'symbol')
+            yield part;
+        else
+            yield* part;
+    }
+    yield RestoreLineMode;
+}
+function* indent(...parts) {
+    yield IncIndent;
+    for (const part of parts) {
+        if (typeof part === 'string' || typeof part === 'symbol')
+            yield part;
+        else
+            yield* part;
+    }
+    yield DecIndent;
+}
+function* jsDoc(docs) {
+    yield `/**`;
+    if (typeof docs === 'string') {
+        yield ` * ${docs}`;
+    }
+    else {
+        yield ` * ${docs.description}`;
+        if (docs.abiDescription) {
+            yield ' *';
+            yield ` * ${docs.abiDescription}`;
+        }
+        if (docs.params || docs.returns) {
+            yield ' *';
+        }
+        for (const [paramName, paramDesc] of Object.entries(docs.params ?? {})) {
+            yield ` * @param ${paramName} ${paramDesc}`;
+        }
+        if (docs.returns)
+            yield ` * @returns ${docs.returns}`;
+    }
+    yield ' */';
+}
+function writeDocumentPartsTo(document, { indent = '  ', ...options }, writer) {
+    if (options.header)
+        writer.write(`${options.header}\n`);
+    if (options.disableEslint)
+        writer.write('/* eslint-disable */\n');
+    const lineModes = [NewLineMode];
+    const currentLineMode = () => lineModes.at(-1) ?? NewLineMode;
+    let curIndent = '';
+    for (const part of document) {
+        switch (part) {
+            case IncIndent:
+                curIndent += indent;
+                break;
+            case DecIndent:
+                curIndent = curIndent.slice(0, -indent.length);
+                break;
+            case DecIndentAndCloseBlock:
+                curIndent = curIndent.slice(0, -indent.length);
+                writer.write(`${curIndent}}\n`);
+                break;
+            case NewLineMode:
+                lineModes.push(NewLineMode);
+                if (writer.last.slice(-1)[0] !== '\n') {
+                    writer.write('\n');
+                }
+                break;
+            case InlineMode:
+                lineModes.push(InlineMode);
+                break;
+            case RestoreLineMode:
+                lineModes.pop();
+                if (currentLineMode() === NewLineMode && writer.last.slice(-1)[0] !== '\n') {
+                    writer.write('\n');
+                }
+                break;
+            case PropertyDelimiter:
+                if (currentLineMode() === NewLineMode) {
+                    writer.write('\n');
+                }
+                else {
+                    writer.write(', ');
+                }
+                break;
+            case NewLine:
+                writer.write('\n');
+                break;
+            default:
+                if (writer.last.slice(-1)[0] === '\n')
+                    writer.write(curIndent);
+                writer.write(part);
+                if (currentLineMode() === NewLineMode)
+                    writer.write('\n');
+                break;
+        }
+    }
+}
+
+export { DecIndent, DecIndentAndCloseBlock, IncIndent, InlineMode, NewLine, NewLineMode, PropertyDelimiter, RestoreLineMode, indent, inline, jsDoc, writeDocumentPartsToStream, writeDocumentPartsToString };

package/package.json

@@ -2,12 +2,15 @@
   "main": "index.js",
   "types": "index.d.ts",
   "name": "@algorandfoundation/algokit-client-generator",
-  "version": "2.6.0-beta.1",
+  "version": "2.6.1-beta.1",
   "description": "Generates a TypeScript client for interacting with, and deploying ARC-0032 smart contracts on the Algorand Blockchain.",
   "private": false,
+  "engines": {
+    "node": ">=19.0"
+  },
   "bin": {
-    "@algorandfoundation/algokit-client-generator": "bin/cli.js",
-    "algokitgen": "bin/cli.js"
+    "@algorandfoundation/algokit-client-generator": "bin/cli.mjs",
+    "algokitgen": "bin/cli.mjs"
   },
   "author": "Algorand Foundation",
   "license": "MIT",
@@ -19,7 +22,7 @@
     "algosdk": "^2.7.0",
     "chalk": "^4.1.2",
     "change-case": "^4.1.2",
-    "commander": "^11.0.0",
+    "commander": "^11.1.0",
     "jsonschema": "^1.4.1"
   },
   "publishConfig": {

package/schema/application.schema.json.cjs

@@ -0,0 +1,374 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var $schema = "http://json-schema.org/draft-07/schema";
+var title = "AlgoAppSpec";
+var type = "object";
+var required = [
+	"contract",
+	"schema",
+	"source",
+	"state"
+];
+var additionalProperties = true;
+var properties = {
+	hints: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#/definitions/Hint"
+		}
+	},
+	source: {
+		$ref: "#/definitions/AppSources"
+	},
+	contract: {
+		$ref: "contract.schema.json"
+	},
+	schema: {
+		$ref: "#/definitions/SchemaSpec"
+	},
+	state: {
+		$ref: "#/definitions/StateSchemaSpec"
+	},
+	bare_call_config: {
+		$ref: "#/definitions/CallConfig"
+	}
+};
+var definitions = {
+	AVMType: {
+		description: "AVM data type",
+		"enum": [
+			"uint64",
+			"bytes"
+		]
+	},
+	DeclaredSchemaValueSpec: {
+		type: "object",
+		required: [
+			"type",
+			"key"
+		],
+		additionalProperties: true,
+		properties: {
+			type: {
+				description: "The type of the value",
+				$ref: "#/definitions/AVMType"
+			},
+			key: {
+				description: "The name of the key",
+				type: "string"
+			},
+			descr: {
+				description: "A description of the variable",
+				type: "string"
+			},
+			"static": {
+				description: "Whether the value is set statically (at create time only) or dynamically",
+				type: "boolean"
+			}
+		}
+	},
+	ReservedSchemaValueSpec: {
+		type: "object",
+		required: [
+			"type"
+		],
+		properties: {
+			type: {
+				description: "The type of the value",
+				$ref: "#/definitions/AVMType"
+			},
+			descr: {
+				description: "A description of the variable",
+				type: "string"
+			},
+			max_keys: {
+				description: "The maximum number of slots to reserve",
+				type: "integer"
+			}
+		}
+	},
+	StateSchemaSpec: {
+		type: "object",
+		additionalProperties: true,
+		required: [
+			"global",
+			"local"
+		],
+		properties: {
+			global: {
+				$ref: "#/definitions/StateSchema"
+			},
+			local: {
+				$ref: "#/definitions/StateSchema"
+			}
+		}
+	},
+	StateSchema: {
+		type: "object",
+		additionalProperties: true,
+		required: [
+			"num_byte_slices",
+			"num_uints"
+		],
+		properties: {
+			num_uints: {
+				type: "integer"
+			},
+			num_byte_slices: {
+				type: "integer"
+			}
+		}
+	},
+	SchemaSpec: {
+		description: "The schema for global and local storage",
+		type: "object",
+		additionalProperties: true,
+		properties: {
+			global: {
+				$ref: "#/definitions/Schema"
+			},
+			local: {
+				$ref: "#/definitions/Schema"
+			}
+		}
+	},
+	Schema: {
+		type: "object",
+		additionalProperties: true,
+		properties: {
+			declared: {
+				type: "object",
+				additionalProperties: {
+					$ref: "#/definitions/DeclaredSchemaValueSpec"
+				}
+			},
+			reserved: {
+				type: "object",
+				additionalProperties: {
+					$ref: "#/definitions/ReservedSchemaValueSpec"
+				}
+			}
+		}
+	},
+	AppSources: {
+		type: "object",
+		additionalProperties: true,
+		properties: {
+			approval: {
+				type: "string"
+			},
+			clear: {
+				type: "string"
+			}
+		}
+	},
+	Hint: {
+		type: "object",
+		additionalProperties: true,
+		properties: {
+			read_only: {
+				type: "boolean"
+			},
+			structs: {
+				type: "object",
+				properties: {
+					output: {
+						$ref: "#/definitions/Struct"
+					}
+				},
+				additionalProperties: {
+					$ref: "#/definitions/Struct"
+				}
+			},
+			default_arguments: {
+				additionalProperties: {
+					$ref: "#/definitions/DefaultArgument"
+				}
+			},
+			call_config: {
+				$ref: "#/definitions/CallConfig"
+			}
+		}
+	},
+	CallConfig: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			no_op: {
+				$ref: "#/definitions/CallConfigValue"
+			},
+			opt_in: {
+				$ref: "#/definitions/CallConfigValue"
+			},
+			close_out: {
+				$ref: "#/definitions/CallConfigValue"
+			},
+			update_application: {
+				$ref: "#/definitions/CallConfigValue"
+			},
+			delete_application: {
+				$ref: "#/definitions/CallConfigValue"
+			}
+		}
+	},
+	CallConfigValue: {
+		"enum": [
+			"NEVER",
+			"CALL",
+			"CREATE",
+			"ALL"
+		]
+	},
+	Struct: {
+		type: "object",
+		additionalProperties: true,
+		required: [
+			"name",
+			"elements"
+		],
+		properties: {
+			name: {
+				type: "string"
+			},
+			elements: {
+				type: "array",
+				items: {
+					$ref: "#/definitions/StructElement"
+				}
+			}
+		}
+	},
+	FieldName: {
+		type: "string"
+	},
+	ABIType: {
+		type: "string"
+	},
+	StructElement: {
+		type: "array",
+		minItems: 2,
+		items: [
+			{
+				$ref: "#/definitions/FieldName"
+			},
+			{
+				$ref: "#/definitions/ABIType"
+			}
+		]
+	},
+	DefaultArgument: {
+		description: "Defines a strategy for obtaining a default value for a given ABI arg.",
+		oneOf: [
+			{
+				type: "object",
+				required: [
+					"source",
+					"data"
+				],
+				additionalProperties: true,
+				properties: {
+					source: {
+						description: "The default value should be fetched by invoking an ABI method",
+						"enum": [
+							"abi-method"
+						]
+					},
+					data: {
+						description: "The contract of the ABI method to invoke.",
+						$ref: "contract.schema.json#/definitions/ContractMethod"
+					}
+				}
+			},
+			{
+				type: "object",
+				required: [
+					"source",
+					"data"
+				],
+				additionalProperties: true,
+				properties: {
+					source: {
+						description: "The default value should be fetched from global state",
+						"enum": [
+							"global-state"
+						]
+					},
+					data: {
+						description: "The key of the state variable",
+						type: "string"
+					}
+				}
+			},
+			{
+				type: "object",
+				required: [
+					"source",
+					"data"
+				],
+				additionalProperties: true,
+				properties: {
+					source: {
+						description: "The default value should be fetched from the local state of the sender user",
+						"enum": [
+							"local-state"
+						]
+					},
+					data: {
+						description: "The key of the state variable",
+						type: "string"
+					}
+				}
+			},
+			{
+				type: "object",
+				required: [
+					"source",
+					"data"
+				],
+				additionalProperties: true,
+				properties: {
+					source: {
+						description: "The default value is a constant.",
+						"enum": [
+							"constant"
+						]
+					},
+					data: {
+						description: "The static default value to use.",
+						anyOf: [
+							{
+								type: "string"
+							},
+							{
+								type: "number"
+							},
+							{
+								type: "integer"
+							}
+						]
+					}
+				}
+			}
+		]
+	}
+};
+var appJsonSchema = {
+	$schema: $schema,
+	title: title,
+	type: type,
+	required: required,
+	additionalProperties: additionalProperties,
+	properties: properties,
+	definitions: definitions
+};
+
+exports.$schema = $schema;
+exports.additionalProperties = additionalProperties;
+exports.default = appJsonSchema;
+exports.definitions = definitions;
+exports.properties = properties;
+exports.required = required;
+exports.title = title;
+exports.type = type;