mobx#makeAutoObservable TypeScript Examples

constructor() {
    this._flows = [];
    this._links = [];
    this.l7endpoints = new GroupedPartialConnections();

    makeAutoObservable(this, void 0, {
      autoBind: true,
    });
  }

constructor(
    config: T,
    navigator: WebApplicationNavigator,
    pluginManager: LegendApplicationPluginManager,
  ) {
    makeAutoObservable(this, {
      navigator: false,
      setBlockingAlert: action,
      setActionAlertInfo: action,
      setNotification: action,
      notify: action,
      notifySuccess: action,
      notifyWarning: action,
      notifyIllegalState: action,
      notifyError: action,
    });

    this.config = config;
    this.navigator = navigator;
    this.pluginManager = pluginManager;
    this.navigationContextService =
      new LegendApplicationNavigationContextService();
    this.documentationService = new LegendApplicationDocumentationService(this);
    this.assistantService = new LegendApplicationAssistantService(this);
    this.log.registerPlugins(pluginManager.getLoggerPlugins());
    this.telemetryService.registerPlugins(
      pluginManager.getTelemetryServicePlugins(),
    );
    this.tracerService.registerPlugins(pluginManager.getTracerServicePlugins());
    this.eventService.registerEventNotifierPlugins(
      pluginManager.getEventNotifierPlugins(),
    );
  }

constructor(llmMatch: Required<AUCT.MatchedOrderSnapshot.AsObject>) {
    makeAutoObservable(this, {}, { deep: false, autoBind: true });

    this.matchingRate = llmMatch.matchingRate;
    this.unitsMatched = llmMatch.unitsMatched;
    this.totalSatsCleared = Big(llmMatch.totalSatsCleared);
    this.ask = {
      leaseDurationBlocks: llmMatch.ask.leaseDurationBlocks,
      rateFixed: llmMatch.ask.rateFixed,
    };
    this.bid = {
      leaseDurationBlocks: llmMatch.bid.leaseDurationBlocks,
      rateFixed: llmMatch.bid.rateFixed,
    };
  }

constructor(contents: string) {
    this.contents = contents;
    this.translation = this.tryTranslate();

    makeAutoObservable(this);

    let needsSync = false;
    reaction(
      () => [this.contents],
      () => {
        needsSync = true;
      }
    );

    const SYNC_INTERVAL = 200;
    setInterval(async () => {
      if (needsSync) {
        let translation = this.tryTranslate();
        needsSync = false;
        runInAction(() => {
          this.translation = translation;
        });
      }
    }, SYNC_INTERVAL);
  }

constructor(channel: Channel) {
        this.channel = channel;

        makeAutoObservable(this, {
            channel: false,
            currentRenderer: false,
            scrollPosition: false,
            scrollAnchored: false,
        });

        this.receive = this.receive.bind(this);
        this.edit = this.edit.bind(this);
        this.delete = this.delete.bind(this);

        const client = this.channel.client;
        client.addListener("message", this.receive);
        client.addListener("message/update", this.edit);
        client.addListener("message/delete", this.delete);
    }

constructor(client: Client, data: MemberI) {
        this.client = client;
        this._id = data._id;

        this.nickname = toNullable(data.nickname);
        this.avatar = toNullable(data.avatar);
        this.roles = toNullable(data.roles);

        makeAutoObservable(this, {
            _id: false,
            client: false,
        });
    }

constructor(data?) {
    makeAutoObservable(this, {
      nodeHovering: observable.ref,
      nodeDragging: observable.ref,
      linkHovering: observable.ref,
      pointer: observable.ref,
      nowDataMap: false,
      twoGraph: false,
      canvas: false,
      update: action,
    });
  }

constructor() {
        makeAutoObservable(this);

        reaction(
            () => GlobalState.device,
            async (device) => {
                if (device) {
                    runInAction(() => this.demoMode = new DemoMode(device));
                    const allowed = await this.demoMode!.getAllowed();
                    runInAction(() => this.allowed = allowed);
                    if (allowed) {
                        const enabled = await this.demoMode!.getEnabled();
                        runInAction(() => this.enabled = enabled);
                    }
                } else {
                    this.demoMode = undefined;
                    this.allowed = false;
                    this.enabled = false;
                    this.features.clear();
                }
            },
            { fireImmediately: true }
        );

        // Apply all features when enable
        autorun(() => {
            if (this.enabled) {
                for (const group of FEATURES) {
                    for (const feature of group) {
                        feature.onChange(this.features.get(feature.key) ?? feature.initial);
                    }
                }
            }
        });
    }

constructor(
    private readonly rootStore: RootStore,
    private readonly authService: AuthService
  ) {
    this.getUserProfile()
      .then((user: UserDto) => {
        this.setUser(user);
      })
      .catch((e: APIErrorResponse) => {
        console.log(e);
      });

    makeAutoObservable(this);
  }

constructor() {
        makeAutoObservable(this)
    }

constructor({id}) {
    this.id = id;
    makeAutoObservable(this);
  }

constructor() {
    makeAutoObservable(this, void 0, {
      autoBind: true,
    });
  }

constructor() {
    makeAutoObservable(this, {
      open: action,
      close: action,
      suppressClickawayEventListener: action,
      handleClickaway: action,
    });
  }

constructor() {
		makeAutoObservable(this);
	}

constructor() {
    makeAutoObservable(this);
  }

constructor() {
    makeAutoObservable(this)
  }

constructor() {
    makeAutoObservable(this);
  }

constructor(store: Store, poolAccount: POOL.Account.AsObject) {
    makeAutoObservable(this, {}, { deep: false, autoBind: true });

    this._store = store;
    this.update(poolAccount);
  }