mobx#ObservableMap TypeScript Examples

/**
     * Construct new Layout store.
     */
    constructor() {
        this.lastSection = "home";
        this.lastHomePath = "/";
        this.lastDiscoverPath = "/discover/servers";
        this.lastOpened = new ObservableMap();
        this.openSections = new ObservableMap();

        this.getLastHomePath = this.getLastHomePath.bind(this);

        makeAutoObservable(this);
    }

channelSubset = (channels: ObservableMap<string, Channel>) => {
  const few = values(channels)
    .slice(0, 20)
    .reduce((result, c) => {
      result[c.chanId] = c;
      return result;
    }, {} as Record<string, Channel>);
  return observable.map(few);
}

/**
     * Construct new Unreads store.
     */
    constructor(client: Client) {
        this.channels = new ObservableMap();
        this.loaded = false;
        makeAutoObservable(this);
        this.client = client;
    }

/**
     * Construct new Auth store.
     */
    constructor() {
        this.sessions = new ObservableMap();
        this.current = null;

        // Inject session token if it is provided.
        if (import.meta.env.VITE_SESSION_TOKEN) {
            this.sessions.set("0", {
                session: {
                    name: "0",
                    user_id: "0",
                    token: import.meta.env.VITE_SESSION_TOKEN as string,
                },
            });

            this.current = "0";
        }

        makeAutoObservable(this);
    }

/**
     * Construct new Sync store.
     */
    constructor(state: State) {
        this.state = state;
        this.disabled = new ObservableSet();
        this.revision = new ObservableMap();
        makeAutoObservable(this);
        this.isEnabled = this.isEnabled.bind(this);
    }

/**
     * Construct new Settings store.
     */
    constructor() {
        this.data = new ObservableMap();
        makeAutoObservable(this);

        this.theme = new STheme(this);
        this.sounds = new SAudio(this);
        this.security = new SSecurity(this);
    }

/**
     * Construct new Draft store.
     */
    constructor(state: State) {
        this.plugins = new ObservableMap();
        this.instances = new Map();
        makeAutoObservable(this);

        this.state = state;
    }

private plugins: ObservableMap<string, Plugin>;

/**
     * Map of last channels viewed in servers.
     */
    private lastOpened: ObservableMap<string, string>;

/**
     * Map of section IDs to their current state.
     */
    private openSections: ObservableMap<string, boolean>;

/**
     * Construct new Experiments store.
     */
    constructor() {
        this.server = new ObservableMap();
        this.channel = new ObservableMap();
        makeAutoObservable(this);
    }

private server: ObservableMap<string, NotificationState>;

private channel: ObservableMap<string, NotificationState>;

/**
     * Construct new Draft store.
     */
    constructor() {
        this.drafts = new ObservableMap();
        makeAutoObservable(this);
    }

private data: ObservableMap<string, unknown>;

private revision: ObservableMap<string, number>;

export default class Collection<K, V> extends ObservableMap<K, V> {
    client: Client;

    constructor(client: Client) {
        super();
        this.client = client;
    }
}

private channels: ObservableMap<string, Omit<ChannelUnread, "_id">>;

private drafts: ObservableMap<string, string>;

attrPermissionCache: ObservableMap<string, EntityAttrPermissionValue> = new ObservableMap();

private sessions: ObservableMap<string, Account>;

/** a list of channels used in pending swaps. mapping of chanId to an array of swap IDs */
  swappedChannels: ObservableMap<string, string[]> = observable.map();

/** the collection of swaps */
  swaps: ObservableMap<string, Swap> = observable.map();

/** the collection of sessions */
  sessions: ObservableMap<string, Session> = observable.map();

/** the collection of leases */
  leases: ObservableMap<string, Lease> = observable.map();

/** the collection of orders */
  orders: ObservableMap<string, Order> = observable.map();

/** the collection of pending channels mapped by channelPoint */
  pendingChannels: ObservableMap<string, Channel> = observable.map();

/** the collection of open channels mapped by chanId */
  channels: ObservableMap<string, Channel> = observable.map();

/** the collection of markets (batches grouped by lease duration) */
  markets: ObservableMap<LeaseDuration, Market> = observable.map();