@algorandfoundation/puya-ts 1.2.0-beta.2 → 1.2.0-beta.21

package/index.d.ts

@@ -7,7 +7,7 @@ export { typeRegistry } from './awst_build/type-registry';
 export { TypeResolver } from './awst_build/type-resolver';
 export { compile } from './compile';
 export { processInputPaths } from './input-paths/process-input-paths';
-export { LoggingContext } from './logger';
+export { LoggingContext, LogLevel, LogSource, LogEvent } from './logger';
 export { CompileOptions } from './options';
 export { AbsolutePath } from './util/absolute-path';
 export declare const encodingUtil: {

package/index.mjs

@@ -1,15 +1,18 @@
-import { A as ABICompatibleInstanceType, a as ALL_OP_ENUMS, b as ARC4ArrayType, c as ARC4BoolClass, d as ARC4EncodedType, e as ARC4InstanceType, f as ARC4StrClass, g as ARC4StructClass, h as ARC4StructType, i as ARC4TupleType, j as AccountFunction, k as AddressClass, l as AnyPType, m as ApplicationFunctionType, n as ApplicationTxnFunction, o as ApprovalProgram, p as Arc4TupleGeneric, q as ArrayGeneric, r as ArrayLiteralPType, s as ArrayPType, t as AssetConfigTxnFunction, u as AssetFreezeTxnFunction, v as AssetFunction, w as AssetTransferTxnFunction, B as BaseContractClassType, x as BigIntLiteralPType, y as BigIntPType, z as BigUintFunction, D as BooleanFunction, E as BoxGeneric, F as BoxMapGeneric, G as BoxMapPType, H as BoxPType, I as ByteClass, J as BytesFunction, K as BytesGeneric, L as BytesPType, M as ClassMethodDecoratorContext, N as ClearStateProgram, O as ClusteredContractClassType, P as ClusteredPrototype, Q as ContractClassPType, R as ContractProxyGeneric, S as ContractProxyType, T as DynamicArrayGeneric, U as DynamicArrayType, V as DynamicBytesConstructor, W as DynamicBytesType, X as FixedArrayGeneric, Y as FixedArrayPType, Z as FunctionPType, _ as GeneratorGeneric, $ as GeneratorType, a0 as GenericPType, a1 as GlobalStateGeneric, a2 as GlobalStateType, a3 as GroupTransactionPType, a4 as ImmutableObjectPType, a5 as InnerTransactionPType, a6 as InstanceType, a7 as InternalType, a8 as IntersectionPType, a9 as IntrinsicEnumType, aa as IntrinsicFunctionGroupType, ab as IntrinsicFunctionGroupTypeType, ac as IntrinsicFunctionType, ad as IntrinsicFunctionTypeType, ae as IterableIteratorGeneric, af as IterableIteratorType, ag as ItxnParamsPType, ah as KeyRegistrationTxnFunction, ai as LibClassType, aj as LibFunctionType, ak as LibObjType, al as LocalStateGeneric, am as LocalStateType, an as LogicSigPType, ao as MutableObjectPType, ap as MutableTuplePType, aq as NamespacePType, ar as NumberPType, as as NumericLiteralPType, at as ObjectLiteralPType, au as ObjectWithOptionalFieldsType, av as PType, aw as PaymentTxnFunction, ax as PolytypeClassMethodHelper, ay as PromiseGeneric, az as PromiseType, aA as ReadonlyArrayGeneric, aB as ReadonlyArrayPType, aC as ReadonlyGeneric, aD as ReadonlyTuplePType, aE as ReferenceArrayGeneric, aF as ReferenceArrayType, aG as StaticArrayGeneric, aH as StaticArrayType, aI as StaticBytesGeneric, aJ as StaticBytesType, aK as StringFunction, aL as SuperPrototypeSelector, aM as SuperPrototypeSelectorGeneric, aN as TemplateVarFunction, aO as TransactionFunction, aP as TransactionFunctionType, aQ as TransientType, aR as TypeParameterType, aS as TypedApplicationCallResponseGeneric, aT as TypedApplicationCallResponseType, aU as UFixedNxMGeneric, aV as UFixedNxMType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UintN128Class, a$ as UintN16Class, b0 as UintN256Class, b1 as UintN32Class, b2 as UintN64Class, b3 as UintN8Class, b4 as UintNGeneric, b5 as UintNType, b6 as UnionPType, b7 as UnsupportedType, b8 as abiCallFunction, b9 as accountPType, ba as anyGtxnType, bb as anyItxnParamsType, bc as anyItxnType, bd as anyPType, be as applicationCallGtxnType, bf as applicationCallItxnFn, bg as applicationCallItxnParamsType, bh as applicationItxnType, bi as applicationPType, bj as arc28EmitFunction, bk as arc4AbiMethodDecorator, bl as arc4AddressAlias, bm as arc4BareMethodDecorator, bn as arc4BaseContractType, bo as arc4BooleanType, bp as arc4ByteAlias, bq as arc4StringType, br as arc4StructBaseType, bs as arc4Uint64, bt as assertFunction, bu as assertMatchFunction, bv as assetConfigGtxnType, bw as assetConfigItxnFn, bx as assetConfigItxnParamsType, by as assetConfigItxnType, bz as assetFreezeGtxnType, bA as assetFreezeItxnFn, bB as assetFreezeItxnParamsType, bC as assetFreezeItxnType, bD as assetPType, bE as assetTransferGtxnType, bF as assetTransferItxnFn, bG as assetTransferItxnParamsType, bH as assetTransferItxnType, bI as base64PType, bJ as baseContractType, bK as bigIntPType, bL as biguintPType, bM as boolPType, bN as bytesPType, bO as bzeroFunction, bP as cloneFunctionPType, bQ as compileArc4Function, bR as compileFunctionType, bS as compiledContractType, bT as compiledLogicSigType, bU as contractOptionsDecorator, bV as convertBytesFunction, bW as decodeArc4Function, bX as ecPType, bY as ecdsaPType, bZ as encodeArc4Function, b_ as ensureBudgetFunction, b$ as errFunction, c0 as esSymbol, c1 as inputOnlyObjects, c2 as isArrayType, c3 as isObjectType, c4 as isTupleLike, c5 as itoaMethod, c6 as itxnComposePType, c7 as keyRegistrationGtxnType, c8 as keyRegistrationItxnFn, c9 as keyRegistrationItxnParamsType, ca as keyRegistrationItxnType, cb as logFunction, cc as logicSigBaseType, cd as logicSigOptionsDecorator, ce as matchFunction, cf as methodSelectorFunction, cg as mimcConfigurationsPType, ch as neverPType, ci as nullPType, cj as numberPType, ck as onCompleteActionType, cl as opUpFeeSourceType, cm as paymentGtxnType, cn as paymentItxnFn, co as paymentItxnParamsType, cp as paymentItxnType, cq as ptypeToArc4EncodedType, cr as readonlyDecorator, cs as sizeOfFunction, ct as stringPType, cu as submitGroupItxnFunction, cv as transactionTypeType, cw as uint64PType, cx as undefinedPType, cy as unknownPType, cz as urangeFunction, cA as validateEncodingFunctionPType, cB as voidPType, cC as vrfVerifyPType, cD as uint8ArrayToBigInt, cE as uint8ArrayToBase64, cF as uint8ArrayToBase32, cG as uint8ArrayToHex, cH as uint8ArrayToUtf8, cI as base64ToUint8Array, cJ as base32ToUint8Array, cK as hexToUint8Array, cL as bigIntToUint8Array, cM as utf8ToUint8Array } from './options-Cbipn6vL.js';
-export { cU as AbsolutePath, cT as CompileOptions, cS as LoggingContext, cN as SourceLocation, cQ as TypeResolver, cR as processInputPaths, cO as registerPTypes, cP as typeRegistry } from './options-Cbipn6vL.js';
-export { c as compile } from './compile-Cj7vjDbw.js';
-import 'arcsecond';
+import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationFunctionType, u as ApplicationTxnFunction, w as ApprovalProgram, x as ArrayGeneric, y as ArrayLiteralPType, z as ArrayPType, B as AssetConfigTxnFunction, D as AssetFreezeTxnFunction, E as AssetFunction, F as AssetTransferTxnFunction, G as BaseContractClassType, H as BigIntLiteralPType, J as BigIntPType, K as BigUintFunction, M as BooleanFunction, N as BoxGeneric, Q as BoxMapGeneric, R as BoxMapPType, S as BoxPType, T as BytesFunction, U as BytesGeneric, V as BytesPType, W as ClassMethodDecoratorContext, X as ClearStateProgram, Y as ClusteredContractClassType, Z as ClusteredPrototype, _ as ContractClassPType, $ as FixedArrayGeneric, a0 as FixedArrayPType, a1 as FunctionPType, a2 as GeneratorGeneric, a3 as GeneratorType, a4 as GenericPType, a5 as GlobalStateGeneric, a6 as GlobalStateType, a7 as GroupTransactionPType, a8 as ImmutableObjectPType, a9 as InnerTransactionPType, aa as InstanceType, ab as InternalType, ac as IntersectionPType, ad as IntrinsicEnumType, ae as IntrinsicFunctionGroupType, af as IntrinsicFunctionGroupTypeType, ag as IntrinsicFunctionType, ah as IntrinsicFunctionTypeType, ai as IterableIteratorGeneric, aj as IterableIteratorType, ak as ItxnParamsPType, al as KeyRegistrationTxnFunction, am as LibClassType, an as LibFunctionType, ao as LibObjType, ap as LocalStateGeneric, aq as LocalStateType, ar as LogicSigPType, as as MutableObjectPType, at as MutableTuplePType, au as NamespacePType, av as NumberPType, aw as NumericLiteralPType, ax as ObjectLiteralPType, ay as ObjectWithOptionalFieldsType, az as PType, aA as PaymentTxnFunction, aB as PolytypeClassMethodHelper, aC as PromiseGeneric, aD as PromiseType, aE as ReadonlyArrayGeneric, aF as ReadonlyArrayPType, aG as ReadonlyGeneric, aH as ReadonlyTuplePType, aI as ReferenceArrayGeneric, aJ as ReferenceArrayType, aK as StringFunction, aL as SuperPrototypeSelector, aM as SuperPrototypeSelectorGeneric, aN as TemplateVarFunction, aO as TransactionFunction, aP as TransactionFunctionType, aQ as TransientType, aR as TypeParameterType, aS as Uint64EnumMemberLiteralType, aT as Uint64EnumMemberType, aU as Uint64EnumType, aV as Uint64Function, aW as UnionPType, aX as UnsupportedType, e as accountPType, h as anyGtxnType, aY as anyItxnParamsType, aZ as anyItxnType, a_ as anyPType, n as applicationCallGtxnType, a$ as applicationCallItxnFn, b0 as applicationCallItxnParamsType, b1 as applicationItxnType, f as applicationPType, b2 as arc28EmitFunction, b3 as arc4AbiMethodDecorator, b4 as arc4BareMethodDecorator, b5 as arc4BaseContractType, b6 as assertFunction, b7 as assertMatchFunction, i as assetConfigGtxnType, b8 as assetConfigItxnFn, b9 as assetConfigItxnParamsType, ba as assetConfigItxnType, m as assetFreezeGtxnType, bb as assetFreezeItxnFn, bc as assetFreezeItxnParamsType, bd as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, be as assetTransferItxnFn, bf as assetTransferItxnParamsType, bg as assetTransferItxnType, bh as base64PType, bi as baseContractType, bj as bigIntPType, bk as biguintPType, bl as boolPType, bm as bytesPType, bn as bzeroFunction, bo as cloneFunctionPType, bp as compileFunctionType, bq as compiledContractType, br as compiledLogicSigType, bs as contractOptionsDecorator, bt as ecPType, bu as ecdsaPType, bv as ensureBudgetFunction, bw as errFunction, bx as esSymbol, by as inputOnlyObjects, bz as isArrayType, bA as isObjectType, bB as isTupleLike, bC as itoaMethod, bD as itxnComposePType, k as keyRegistrationGtxnType, bE as keyRegistrationItxnFn, bF as keyRegistrationItxnParamsType, bG as keyRegistrationItxnType, bH as logFunction, bI as loggedAssertFunction, bJ as loggedErrFunction, bK as logicSigBaseType, bL as logicSigOptionsDecorator, bM as matchFunction, bN as mimcConfigurationsPType, bO as neverPType, bP as nullPType, bQ as numberPType, bR as onCompleteActionType, bS as opUpFeeSourceType, p as paymentGtxnType, bT as paymentItxnFn, bU as paymentItxnParamsType, bV as paymentItxnType, bW as readonlyDecorator, bX as stringPType, bY as submitGroupItxnFunction, bZ as transactionTypeType, b_ as uint64PType, b$ as undefinedPType, c0 as unknownPType, c1 as urangeFunction, c2 as validateEncodingFunctionPType, v as voidPType, c3 as vrfVerifyPType, c4 as uint8ArrayToBigInt, c5 as uint8ArrayToBase64, c6 as uint8ArrayToBase32, c7 as uint8ArrayToUtf8, c8 as base64ToUint8Array, c9 as base32ToUint8Array, ca as bigIntToUint8Array, cb as utf8ToUint8Array } from './contract-class-model-CLKobHyV.js';
+export { A as AbsolutePath, L as LogLevel, cc as LogSource, a as LoggingContext, cd as SourceLocation } from './contract-class-model-CLKobHyV.js';
+import { A as ARC4ArrayType, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleType, h as AddressClass, i as Arc4TupleGeneric, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesConstructor, m as DynamicBytesType, S as StaticArrayGeneric, n as StaticArrayType, o as StaticBytesGeneric, p as StaticBytesType, T as TypedApplicationCallResponseGeneric, q as TypedApplicationCallResponseType, U as UFixedNxMGeneric, r as UFixedNxMType, s as UintN128Class, t as UintN16Class, u as UintN256Class, v as UintN32Class, w as UintN64Class, x as UintN8Class, y as UintNGeneric, z as UintNType, E as abiCallFunction, F as arc4AddressAlias, G as arc4BooleanType, H as arc4ByteAlias, I as arc4StringType, J as arc4StructBaseType, K as arc4Uint64, L as compileArc4Function, M as convertBytesFunction, N as decodeArc4Function, O as encodeArc4Function, P as methodSelectorFunction, Q as sizeOfFunction, R as uint8ArrayToHex, V as hexToUint8Array } from './options-B93nVWrL.js';
+export { W as CompileOptions, X as TypeResolver, Y as processInputPaths, Z as registerPTypes, _ as typeRegistry } from './options-B93nVWrL.js';
+export { c as compile } from './compile-D0CpLiRh.js';
+import 'typescript';
 import 'node:fs';
 import 'node:util';
 import 'pathe';
-import 'tslib';
-import 'node:buffer';
-import 'typescript';
 import 'node:crypto';
+import 'polytype';
 import 'node:async_hooks';
+import 'arcsecond';
+import 'tslib';
+import 'node:buffer';
 import 'cross-spawn';
 import 'util';
 import 'path';
@@ -17,12 +20,15 @@ import 'os';
 import 'crypto';
 import 'net';
 import 'change-case';
-import 'polytype';
 import 'glob';
 import 'minimatch';
-import './resolve-puya-path-CsuzbFH2.js';
+import './arc4-clientgen-C7FQSt3R.js';
+import '@algorandfoundation/algokit-utils/abi';
 import 'fs';
+import 'fs/promises';
+import './semver-BPw8lYGI.js';
 import 'node:url';
+import './resolve-puya-path-D7qDcdPx.js';
 import 'signal-exit';
 import 'tar';
 import 'node:zlib';
@@ -224,6 +230,8 @@ var forExport = /*#__PURE__*/Object.freeze({
     keyRegistrationItxnParamsType: keyRegistrationItxnParamsType,
     keyRegistrationItxnType: keyRegistrationItxnType,
     logFunction: logFunction,
+    loggedAssertFunction: loggedAssertFunction,
+    loggedErrFunction: loggedErrFunction,
     logicSigBaseType: logicSigBaseType,
     logicSigOptionsDecorator: logicSigOptionsDecorator,
     matchFunction: matchFunction,
@@ -238,7 +246,6 @@ var forExport = /*#__PURE__*/Object.freeze({
     paymentItxnFn: paymentItxnFn,
     paymentItxnParamsType: paymentItxnParamsType,
     paymentItxnType: paymentItxnType,
-    ptypeToArc4EncodedType: ptypeToArc4EncodedType,
     readonlyDecorator: readonlyDecorator,
     sizeOfFunction: sizeOfFunction,
     stringPType: stringPType,

package/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/awst_build/ptypes/for-export.ts","../src/index.ts"],"sourcesContent":["/* This file aggregates all ptypes into a single export for external consumption of the compiler api */\nexport { ptypeToArc4EncodedType } from '../arc4-util'\nexport * from './arc4-types'\nexport * from './index'\n","import {\n  base32ToUint8Array,\n  base64ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n  uint8ArrayToHex,\n  uint8ArrayToUtf8,\n  utf8ToUint8Array,\n} from './util'\nimport './util/polyfills'\n\nexport { SourceLocation } from './awst/source-location'\nexport * as ptypes from './awst_build/ptypes/for-export'\nexport { registerPTypes } from './awst_build/ptypes/register'\nexport { typeRegistry } from './awst_build/type-registry'\nexport { TypeResolver } from './awst_build/type-resolver'\nexport { compile } from './compile'\nexport { processInputPaths } from './input-paths/process-input-paths'\nexport { LoggingContext } from './logger'\nexport { CompileOptions } from './options'\nexport { AbsolutePath } from './util/absolute-path'\n\nexport const encodingUtil = {\n  utf8ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  base32ToUint8Array,\n  base64ToUint8Array,\n  uint8ArrayToUtf8,\n  uint8ArrayToHex,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACyBO,MAAM,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}
+{"version":3,"file":"index.mjs","sources":["../src/awst_build/ptypes/for-export.ts","../src/index.ts"],"sourcesContent":["/* This file aggregates all ptypes into a single export for external consumption of the compiler api */\nexport * from './arc4-types'\nexport * from './index'\n","import {\n  base32ToUint8Array,\n  base64ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n  uint8ArrayToHex,\n  uint8ArrayToUtf8,\n  utf8ToUint8Array,\n} from './util'\nimport './util/polyfills'\n\nexport { SourceLocation } from './awst/source-location'\nexport * as ptypes from './awst_build/ptypes/for-export'\nexport { registerPTypes } from './awst_build/ptypes/register'\nexport { typeRegistry } from './awst_build/type-registry'\nexport { TypeResolver } from './awst_build/type-resolver'\nexport { compile } from './compile'\nexport { processInputPaths } from './input-paths/process-input-paths'\nexport { LoggingContext, LogLevel, LogSource, LogEvent } from './logger'\nexport { CompileOptions } from './options'\nexport { AbsolutePath } from './util/absolute-path'\n\nexport const encodingUtil = {\n  utf8ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  base32ToUint8Array,\n  base64ToUint8Array,\n  uint8ArrayToUtf8,\n  uint8ArrayToHex,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACyBO,MAAM,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}

package/logger/index.d.ts

@@ -48,6 +48,7 @@ export declare const logger: PuyaLogger;
 export declare const patchErrorLocation: <TArgs extends unknown[], TReturn>(action: (...args: TArgs) => TReturn, sourceLocation: SourceLocation) => (...args: TArgs) => TReturn;
 export declare class LoggingContext {
     #private;
+    treatWarningsAsErrors: boolean;
     get logEvents(): readonly LogEvent[];
     get logEventsByPath(): {
         readonly [path: string]: readonly LogEvent[];