low: the stream of conciseness 0.7+ roadmap

"ready" -> "trigger"
"sub" -> "update.by"

// cast -- to
v.cast.signal.trigger()
v.cast.value.trigger()
v.to(console.log);

value(0).view()
value(0).view.untrack()

value(0).flow() //-- stoppable
value(0).flow.untrack()
value(0).flow.filter()
value(0).flow.filter.untrack()
value(0).flow.filter.not()
value(0).flow.filter.not.untrack()

value(0).chan() //-- stoppable
value(0).chan.untrack()
value(0).chan.filter()
value(0).chan.filter.untrack()
value(0).chan.filter.not()
value(0).chan.filter.not.untrack()

value(0).chan.debounce(300)
value(0).chan.throttle(300)

value(0).pre() //-- stoppable (untracked by default) expression
value(0).pre.track()

value(0).pre.filter()
value(0).pre.filter.untrack()
value(0).pre.filter.not()
value(0).pre.filter.not.untrack()

value(0).pre.chan()
value(0).pre.chan.untrack()
value(0).pre.chan.filter()
value(0).pre.chan.filter.untrack()
value(0).pre.chan.filter.not()
value(0).pre.chan.filter.not.untrack()

value(0).pre.chan.debounce(300)
value(0).pre.chan.throttle(300)

value(0).to.signal()
value(0).to.value()
value(0).to.ready()
value(0).to.flag()
value(0).to.flag.not()

value(0).promise

value(0).join(a, b)
value(0).join.chan(a, b)
value(0).join.signal(a, b)
value(0).join.signal.ready(a, b)
value(0).join.value(a, b)
value(0).join.value.ready(a, b)

value(0).sync(b)

value(0).interceptor()
value(0).sub.interceptor()

value(0).sub()
value(0).sub.once()

value(0).watch()
value(0).watch.once()

value()
value.from()
value.ready()
value.ready.from()
value.ready.flag()
value.ready.flag.from()
value.flag()
value.flag.from()

signal()
signal.from()
signal.ready()              // proposal: ready to trigger rename?
signal.ready.from()
signal.ready.flag()
signal.ready.flag.from()
signal.flag()
signal.flag.from()

pool()

pool().pre.throttle()
pool().pre.pipe(pool(), pool())
pool().pipe(pool(), pool())

Working started:
[+] reset
[+] promise

Backlog from api-0.6 implementation

  [] trigger should be touchable
  [] value.touchable(initial) <- The ".from" construction not available for values with "initial" dependency requireds
  [] signal.touchable(initial)

  [] v.as.readonly()
  [] flow.resolve
  [] flow as root level exportable factory function
  [] .chan
  [] value.trigger.from
  [] value.trigger.flag.from
  [] .map <- sysnonym for .view (on thinking)
  [] x.group -- x.op -- x.block
    x.block((ctx) => ({  // if returns non undefined
      a: ctx.a,
      b: ctx.a.select()
    })).b.val
  [] v.as.signal(), v.as.trigger.flag()

Backlog:
[] Add callback to join, and combine. After It possible to use object config for join with callback
[] .as.trigger
[] .as.value.trigger
[] .as.signal.trigger

[] signal.trigger.resolved
[] value.trigger.resolved

[] test case "should work signal.trigger with configured .pre"

[] signal.trigger.from
[] value.trigger.from

[] Add Loader example to documentation

  // Second example
  const Loader = () => {
    const count = value(0);

    return {
      start: count.updater(v => v + 1),
      stop: count.updater(v => v - 1),
      pending: count.select(v => v > 0)
    }
  }

Join brainstorm:

[] Add track|untrack for join with callback

I think better way in that case is removing callback support for current version.
because without callback for combine and join no have any conficts for syntax.
I can use track|untrack for join without callback with no disharmony

--> decision for version 0.6:
  [] remove callback support for join and combine
  [] Add track|untrack for join
    ...disharmony was stay
--> decision number two) The second
  [] rename join to "attach" or "merge"

    Task: The saving consistency of track|untrack for append|attach|join|merge function

    Have a reason for join without tracking for a set of rective values.

      Have a reason join for signals?

value.combine() -> ok
value.join() -> ok

I cant implement signal.combine([], fn and s.join([], fn) because I have not flag for ready all
signals from argument

signal.combine() -> not ok
signal.join() -> not ok

maybe support combine and join only for values now.
For signal I can use merge

const s = signal(0);
s.merge([() => s.val, ...]).val == 0; without callback

Summary:
[] I should implement value.combine([]|{}, fn?), and value(0).combine([] | {}, fn?)
- track|untrack for combine? (I can not support untrack for combine values)

[] No have similar for signal in 0.6 versions.

value.from(() => ({
a: a.val,
b: b.val
}))
value.combine({ a, b }) -> better...
Always tracked, and it used only for values

value(0).combine - have a problem with track|untrack semantic not for 0.6 version.

I should make only value.combine. Aren't It?
Ok. For 0.6 its enough

Backlog
[] as.value(dafault_value?)
[] support reactionable for untrack
[] value().get.untrack()

Backlog
[] Add default for resolve "Will" type

  const v = value(0).filter().default(0)

Backlog:

const r = signal();
const u = signal<number>();

const v = value(0);

v.reset.by(r);

v.update.by(u, (state, up_value, up_value_prev) => {
  return state + (up_value - (up_value_prev || 0));
});

u(10);
r();

And I think to very interesting idea is the convert "reset" function method to signal

const a = value(0);

a.reset.to(() => console.log("reset"));

proposal: local

cosnt v = value(0);

v.flow((value) => {
  const ticket = local(() => wait(k));
  if (!ticket.val) return flow.stop();
  return value;
});

v.flow.filter(() => {
  return local(() => wait(k)).val
});

local(expr) // <- bind only first time not necessary bind it every time
                   // if you need bind every time you should use plain function not local expression.
                   // synonim of local(expr, []);
local(expr, [<real value dep>, ...])
local(expr, <refresh symbol or expression>);

// or all combination of that
local(expr, <refresh symbol or expression>, [<real value dep>, ...]);
local(expr, [<real value dep>, ...], <refresh symbol or expression>);

proposal: wait

const v = value(0);
const s = signal(0);

// wait.all([v, s]) - it is a ready (trigger)

await wait.all([v, s]).promise
await wait.once([v, s]).promise

wait(v) // similar to signal.trigger.from(v) or v.to.signal.trigger()

const k = signal(0);
const m = value(0);

v.flow.wait(m)
  .flow.wait.all(k, m) // or synonim to .flow.wait.all([k, m]) -- think about
  .flow.wait.race(k, m)
  .to((v) => console.log(v));

const k = signal(0);
const m = value(0);

v.flow.wait(m, (v_val, m_val) => return v_val + m_val)
  .flow.wait.all([k, m], (v_val, [k_val, m_val]) => return v_val + k_val + m_val) // or stop of course (maybe I can get resolve???)
  .flow.wait.race([k, m], (v_val, [k_val, m_val], resolve, v_val_prev) => {});
  .to((v) => console.log(v));

up: replace useMemo by useRef

You may rely on useMemo as a performance optimization, not as a semantic guarantee. In the future, React may choose to “forget” some previously memoized values and recalculate them on next render, e.g. to free memory for offscreen components. Write your code so that it still works without useMemo — and then add it to optimize performance.

proposal: chain

Think about "chain" abstraction

const a = value(0);
const b = chain(() => a.val);

assert(b.val === undefined);
a(5);
assert(b.val === undefined);

b.input.to(b.output); // "to" better than "watch"
a(6);
assert(b.val === 6);

proposal: pool.flat

private finish_purchase = pool(async () => {
    if (this.finish_purchase.count > 1) return; // not count.val here
  });

const a = pool(async () => {
    if (a.count.val > 1) return a.threads[0].promise; // Return promise from first thread
}

assert(a.flat.pending === false);
assert(chan(async () => {}).flat.pending === false);

proposal: signal.union

Collect signals from several values and signals.
Worked as last value of set

const a = value(0);
const b = signal(0);

const u = signal.union(a, b);

u.val === 0;
a(5);
u.val === 5;
b(10);
u.val === 10;

proposal: input as exportable api function

input.handler <- (ev) => ev.target.value
// proposal for another names.
// input.delegate
// input.change
// input.event

input.valid
input.valid.pending

input.validator(
  signal<string>().map((state) => /a/.test(state))
)
// input.validator.async() // or

// Interested but no consistency to other code base.
// input.validator((signal) => {
//   return signal.as.chan().map(async () => {})
// });

// Final perfect version
input.validator([
  signal<string>().filter() <-- what will happens if validator will be stopped
  chan<string>().map(async (state) => await fetch_is_valid(state)),
  (state) => /aa/.test(state),
  async (state) => await ext_test(state)
]);

proposal: remove select.multiple

Improve "select" to "select.multiple" signature

const s = select({ a: (state) => state.a });

The argument can be function, reactive container, object map, or array tuple.

proposal: reactive container as argument of "map" (and array of)

const pipe_double = signal<number>().map(state => state * 2);

value(1).map(pipe_double).val // 2
value(1).map([pipe_double, pipe_double]).val // 4

// Use signature as an array or as reactive container, or usual function signature.

low: test ts typings

https://github.com/reduxjs/reselect/blob/master/typescript_test/test.ts#L479

 // typings:expect-error     
 const baz2: string = baz;

fix: update component warn from modification in the render function

https://codesandbox.io/s/realar-api-unsubscribe-scopes-control-0sziu?file=/src/App.tsx

Warning: Cannot update a component (`fn`) while rendering a different component (`Form`). To locate the bad setState() call inside `Form`, follow the stack trace as described in https://reactjs.org/link/setstate-in-render
    at Form (https://0sziu.csb.app/src/App.tsx:30:35)
    at fn (https://0sziu.csb.app/node_modules/realar/build/index.js:697:30)

brainstorm: signals two directional synchronization

const a = signal<number>();
const b = signal<number>();

sync(a, b);
sync(b, a);

Signals connection without the infinity loop error

I should realize a way to the bi-directional connection between signals.

const a = signal(0);
const b = signal(0);

sync.bi(a, b);
a.val++
b.val++
assert(a.val === 2)

signal.from.select broken ts types with tuples

signal
  .from(() => {
    return [
      buyAnnualLocale.val,
      sharedPurchases().annual_subscription.val
    ]
  })
  .select(([locale, sub]) => { // both variables have one type "string | Subscription | undefined"
    if (!sub) return void 0;
    const localized_price = (sub as any)?.localizedPrice;
    if (!localized_price) return void 0;
    
    return locale.text
  })

value(false) broken types for ts <4

const y: Value<boolean> = value(false);
/*
Type 'Value<false, false>' is not assignable to type 'Value<boolean, boolean>'.
  Type 'Value<false, false>' is not assignable to type '{ (value: boolean): void; set(value: boolean): void; }'.
    Types of parameters 'value' and 'value' are incompatible.
      Type 'boolean' is not assignable to type 'false'.ts(2322)
*/

proposal: manual rerun cycle outside

const h = cycle(() => {});
h.stop();
h.run();

proposal: shortcut not

sharedEye().enabled
    .as.signal()
    .filter()
    .filter(isNext.map(flag => !flag)) // TODO: shortcut not isNext.not()

proposal: value with no initial parameter

export const swipeAnimDirection = value<undefined | 'up' | 'down'>();

proposal: typings improvement for filter

 value<void | number>()
    .as.signal()
    .filter() // Should remove undefined | null | void from Will signal type
    .to(onlyNumberSignal);

proposal: new Scope api

const MyLogic = (initial: string) => {}

const MyScope = scope(MyLogic)

const A = () => {
  const B = useJsx(() => {
    const logic = useScoped(MyLogic)

    /* proposal: use scope logic from local section
    useLocal(() => {
      const logic = scoped(MyLogic)  // Warning scope recreation
      const logic = scoped.current(MuLogic) // Think about
    });
    */
    return
  });
  return <MyScope initial={'hello'}><B>{children}</B></MyScope>
}

fix: callback of sync or to methods should be untracked ... hmm.. check it

loader_queue.sync(async queue => {
  // should be untracked here
})

fix: typings for select without parameter

  const toggle = value(false).pre((_, state) => !state);
  const enabled = toggle.select(); // Incorrect: ValueReadonly<unknown>

proposel: value.will

const t = value.will<number>();
expect(t.val).toBeUndefined();
t.map(n: number => n + 1);

proposal

const takeUser = value();
const takeAuth = value();
takeAuth.onChange(takeUser.andUpdate)
takeUser.andSet()
takeUser() - alias for takeUser.andGet

const start = signal();
start.get - doesn't allowed
start.fire(new_value)

takeUser.onChange(start.fire)

start.getValue() - returns value instance

isDirty, isUndefined, isTouched
All methods created only by demand.

start.flow
start.pre

takeUser.compose

Navigation Menu

Repository navigation

low: the stream of conciseness 0.7+ roadmap #88

proposal: local

proposal: wait

up: replace useMemo by useRef

proposal: chain

proposal: pool.flat

proposal: signal.union

22 remaining items

proposal: input as exportable api function

proposal: remove select.multiple

proposal: reactive container as argument of "map" (and array of)

low: test ts typings

fix: update component warn from modification in the render function

brainstorm: signals two directional synchronization

signal.from.select broken ts types with tuples

value(false) broken types for ts <4

proposal: manual rerun cycle outside

proposal: shortcut not

proposal: value with no initial parameter

proposal: typings improvement for filter

proposal: new Scope api

fix: callback of sync or to methods should be untracked ... hmm.. check it

fix: typings for select without parameter

proposel: value.will

proposal

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

low: the stream of conciseness 0.7+ roadmap #88

Description

Activity

betula commented on May 10, 2021

betula commented on May 22, 2021

betula commented on Jun 3, 2021

betula commented on Jun 6, 2021

betula commented on Jun 6, 2021

betula commented on Jun 6, 2021

betula commented on Jun 7, 2021

betula commented on Jun 7, 2021

proposal: local

betula commented on Jun 7, 2021

proposal: wait

betula commented on Jun 7, 2021

up: replace useMemo by useRef

betula commented on Jun 7, 2021

proposal: chain

betula commented on Jun 7, 2021

proposal: pool.flat

betula commented on Jun 7, 2021

proposal: signal.union

22 remaining items

betula commented on Jun 10, 2021

proposal: input as exportable api function

proposal: remove select.multiple

proposal: reactive container as argument of "map" (and array of)

betula commented on Jun 11, 2021

low: test ts typings

betula commented on Jun 12, 2021

fix: update component warn from modification in the render function

betula commented on Jun 12, 2021

brainstorm: signals two directional synchronization

betula commented on Jun 18, 2021

signal.from.select broken ts types with tuples

betula commented on Jun 23, 2021

value(false) broken types for ts <4

betula commented on Jun 23, 2021

proposal: manual rerun cycle outside

betula commented on Jun 24, 2021

proposal: shortcut not

betula commented on Jun 24, 2021

proposal: value with no initial parameter

betula commented on Jun 24, 2021

proposal: typings improvement for filter

betula commented on Jun 27, 2021

proposal: new Scope api

betula commented on Jun 27, 2021

fix: callback of sync or to methods should be untracked ... hmm.. check it

betula commented on Jun 27, 2021

fix: typings for select without parameter

betula commented on Nov 8, 2021

proposel: value.will

betula commented on Nov 15, 2021

proposal

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions