@neo-one/smart-contract-compiler/dist/esm/compile/builtins/object/keys.js

NEO•ONE TypeScript smart contract compiler.

import { tsUtils } from '@neo-one/ts-utils';
import { Types } from '../../constants';
import { BuiltinMemberCall } from '../BuiltinMemberCall';
export class ObjectKeys extends BuiltinMemberCall {
    emitCall(sb, _func, node, optionsIn) {
        if (tsUtils.argumented.getArguments(node).length < 1) {
            return;
        }
        const options = sb.pushValueOptions(optionsIn);
        const arg = tsUtils.argumented.getArguments(node)[0];
        const processArray = (innerOptions) => {
            sb.emitHelper(node, innerOptions, sb.helpers.unwrapArray);
            sb.emitOp(node, 'ARRAYSIZE');
            sb.emitHelper(node, innerOptions, sb.helpers.arrRange({
                map: (innerInnerOptions) => {
                    sb.emitHelper(node, innerInnerOptions, sb.helpers.wrapNumber);
                    sb.emitHelper(node, innerInnerOptions, sb.helpers.toString({ type: undefined, knownType: Types.Number }));
                    sb.emitHelper(node, innerInnerOptions, sb.helpers.wrapString);
                },
            }));
            sb.emitHelper(node, innerOptions, sb.helpers.wrapArray);
        };
        const emptyArray = (innerOptions) => {
            sb.emitOp(node, 'DROP');
            sb.emitHelper(node, innerOptions, sb.helpers.createArray);
        };
        const throwTypeError = (innerOptions) => {
            sb.emitOp(node, 'DROP');
            sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
        };
        const processObject = (innerOptions) => {
            sb.emitHelper(node, innerOptions, sb.helpers.getPropertyObjectKeys);
            sb.emitHelper(node, innerOptions, sb.helpers.arrMap({
                map: (innerInnerOptions) => {
                    sb.emitHelper(node, innerInnerOptions, sb.helpers.wrapString);
                },
            }));
            sb.emitHelper(node, innerOptions, sb.helpers.wrapArray);
        };
        sb.visit(arg, options);
        sb.emitHelper(node, options, sb.helpers.forBuiltinType({
            type: sb.context.analysis.getType(arg),
            array: processArray,
            arrayStorage: emptyArray,
            boolean: emptyArray,
            buffer: emptyArray,
            null: throwTypeError,
            number: emptyArray,
            object: processObject,
            string: emptyArray,
            symbol: emptyArray,
            undefined: throwTypeError,
            map: emptyArray,
            mapStorage: emptyArray,
            set: emptyArray,
            setStorage: emptyArray,
            error: emptyArray,
            forwardValue: emptyArray,
            iteratorResult: emptyArray,
            iterable: emptyArray,
            iterableIterator: emptyArray,
            transaction: emptyArray,
            output: emptyArray,
            attribute: emptyArray,
            input: emptyArray,
            account: emptyArray,
            asset: emptyArray,
            contract: emptyArray,
            header: emptyArray,
            block: emptyArray,
        }));
        if (!optionsIn.pushValue) {
            sb.emitOp(node, 'DROP');
        }
    }
}

//# sourceMappingURL=keys.js.map