artalar

// BASE

// debounce
const onChange = debounce((ctx, event) => {
  inputAtom(ctx, event.currentTarget.value);
}, 500);

// concurrent
const onChange = concurrent(async (ctx, event) => {
  await ctx.schedule(() => sleep(500));

artalar

// create
export const { useAuth } = createContexts({
  Auth() {
    const [a, setA] = React.useState("a");
    const [b, setB] = React.useState("b");

    return {
      a,
      b,
      setA,

artalar

const ctxBase = createCtx();
const listeners = new Set();
const { subscribe } = ctx;
export const ctx = Object.assign({}, ctxBase, {
  subscribe(...a) {
    const un = subscribe.apply(this, a);

    // logs
    if (a.length === 1) return un;

artalar

export type EventOfTarget<
  Target extends EventTarget,
  Type extends string,
> = Target extends Record<`on${Type}`, infer Cb>
  ? // @ts-expect-error `Cb extends Fn` broke the inference for some reason
    Parameters<Cb>[0] // correct type
  : Target extends Record<'onEvent', (type: Type, cb: infer Cb) => any>
  ? // @ts-expect-error `Cb extends Fn` broke the inference for some reason
    Parameters<Cb>[0] // general type
  : never

artalar

import { $corsProxyEnabled } from '@/src/entities/cors-proxy/model/store'
import { checkInstanceUrl } from '@/src/features/instance/api/check'
import { InstanceCheckResult } from '@/src/features/instance/model/model'
import { BuildConfig } from '@/src/shared/model/build-config'
import {
  combine,
  createEffect,
  createEvent,
  createStore,
  restore,

artalar

export const random = (min = 0, max = Number.MAX_SAFE_INTEGER - 1) =>
  Math.floor(Math.random() * (max - min + 1)) + min

const randomObj = (obj: Record<string, any>, deep: number) => {
  if (deep <= 0) return obj

  const keys = random(5, 10)
  for (let i = 0; i < keys; i++) {
    const type = random(0, 2)
    if (type === 0) {

artalar

import { test } from 'uvu'
import * as assert from 'uvu/assert'
import { createTestCtx } from '@reatom/testing'
import { atom } from '@reatom/core'
import { sleep } from '@reatom/utils'

import { reatomAsync, withAbort } from '@reatom/async'

test('safe pooling', async () => {
  const createTask = reatomAsync(async () => Math.random())

artalar

// new API: reatomAsync automatically cancels the previous request
// and all dependent requests when the new request is triggered

const getList = reatomAsync.from(getListApi).pipe(withDataAtom([]));
const getId = reatomAsync.from(getIdApi).pipe(withAbort());
onUpdate(getId.onFulfilled, (ctx, { data: id }) => getList(ctx, id));

const Component = () => {
  const [list] = useAtom(getList.dataAtom);
  const handleChange = useAction((ctx, e) => getId(ctx, e.currentTarget.value));

artalar

// https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
// https://github.com/reactjs/rfcs/pull/220#issuecomment-1259938816

import React from 'react';

// Allow to access a fresh closures in the function but returns stable reference during rerenders
export function useCallbackRef<T extends (...args: unknown[]) => unknown>(callback: T): T {
  const ref: React.MutableRefObject<{
    stableFn: T;
    callback: T;

artalar

type LLNode<T = any> = {
  prev: null | LLNode<T>
  value: T
  next: null | LLNode<T>
}

const LLAdd = <T>(prev: LLNode<T>, value: T, next = prev.next) => {
  prev.next = { prev, value, next }
  if (next !== null) next.prev = prev.next
}