mobx#makeObservable JavaScript Examples

constructor() {
        makeObservable(this, {
            selectorVisible: observable,
            activeAccount: observable,
            accounts: observable.shallow,
            setActiveAccount: action,
            loadAvailableAccounts: action,
            addAccount: action
        })
    }

/**
     * Create an Account instance from the stored account data
     * @param {Object} params - An object containing account properties
     */
    constructor(params) {
        makeObservable(this, {
            friendlyName: observable,
            displayName: computed,
            shortDisplayName: computed,
            requestAccountSecret: action
        })

        Object.assign(this, params)
    }

constructor(params) {
        super(params)
        this.accountType = ACCOUNT_TYPES.EPHEMERAL_ACCOUNT
        this.friendlyName = 'Stellar account'
        makeObservable(this, {
            secret: observable,
            setSecret: action
        })
    }

constructor() {
        makeObservable(this, {
            status: observable,
            intentRequests: observable,
            origin: observable,
            networkParams: observable,
            intentParams: observable.shallow,
            intentErrors: observable,
            runtimeErrors: observable,
            requestedPubkey: observable,
            selectedAccount: observable,
            selectedAccountInfo: observable,
            isBatchRequest: computed,
            reset: action,
            setIntentError: action,
            confirmRequest: action,
            setStatus: action,
            selectAccount: action,
            cancelAction: action,
            loadSelectedAccountInfo: action
        })
    }

constructor() {
        makeObservable(this, {
            dialogOpen: observable,
            reset: action,
            requestAuthorization: action
        })
        this.sessions = {}

        setTimeout(() => { //TODO: address the loading sequence problem and rewrite this dirty hack
            navigation.history.listen((location, action) => {
                this.dialogOpen = false // hide auth dialog when navigation occurred
            })
        }, 200)

        setInterval(() => {
            const now = new Date().getTime()
            for (let key of Object.keys(this.sessions))
                if (this.sessions[key].expires < now) {
                    delete this.sessions[key]
                }
        }, 5000)
    }

constructor(intent, intentParams) {
        this.intent = intent
        this.intentParams = intentParams
        makeObservable(this, {
            intent: observable,
            intentParams: observable.shallow,
            txContext: observable,
            intentErrors: observable,
            requiresExistingAlbedoAccount: computed,
            autoSubmitToHorizon: computed,
            setTxContext: action
        })
    }

constructor() {
        makeObservable(this, {
            address: observable,
            network: observable,
            history: observable,
            accountData: observable.ref,
            balances: observable.ref,
            pendingLiabilities: observable.ref,
            notificationCounters: observable,
            init: action,
            reset: action,
            error: observable,
            loaded: observable,
            nonExisting: observable,
            balancesWithPriority: computed
        })
        this.pendingLiabilities = {}
        this.balances = {}
    }

constructor(network, address) {
        this.address = address
        this.network = network
        this.records = []
        makeObservable(this, {
            records: observable,
            loadingNextPagePromise: observable.ref,
            loadNextPage: action,
            startStreaming: action,
            addInProgressTx: action,
            addNewTx: action,
            removeInProgressTx: action,
            loading: computed
        })
    }

/**
     * Initialize transaction execution context for an intent request.
     * @param {Transaction} transaction
     * @param {Object} intentParams
     * @param {StellarNetworkParams} networkParams
     */
    constructor(transaction, intentParams, networkParams) {
        makeObservable(this, {
            availableSigners: observable.shallow,
            signatures: observable.shallow,
            signatureSchema: observable,
            setAvailableSigners: action,
            isFullySigned: computed,
            isPartiallySigned: computed,
            setTxSourceAccount: action,
            setTxSequence: action,
            removeSignatureByKey: action,
            removeSignatureByHint: action,
            updateSignatureSchema: action,
            sign: action
        })

        this.tx = transaction
        //TODO: retrieve pre-set signatures from tx
        this.signatures = [...transaction.signatures]
        this.availableSigners = []
        this.mapSignatureKeys()
    }

constructor(props) {
    super(props);
    makeObservable(this, {
      selectedOption: computed,
      options: computed,
    });
  }

constructor() {
    super({
      configName: 'cloud-store',
      defaults: CloudStore.getDefaults(),
    });
    makeObservable(this);
  }

constructor() {
    super({
      configName: 'sync-store',
      defaults: SyncStore.getDefaults(),
    });
    makeObservable(this);
  }

constructor() {
        makeObservable(this, {
            notification: observable,
            showNotification: action,
            closeNotification: action
        })
    }