ctx-core 7.0.1 → 7.1.0

package/all/CACHE_VERSION/index.js

@@ -1,13 +1,15 @@
 /// <reference types="ctx-core" />
-import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { id_be_sig_triple_ } from '../be_sig_triple/index.js'
 import { import_meta_env_ } from '../import_meta_env/index.js'
 export const [
 	CACHE_VERSION$_,
 	CACHE_VERSION_,
 	CACHE_VERSION__set,
-] = /** @type {be_sig_triple_T<false|string>} */ be_sig_triple_(()=>
-	typeof process === 'object' && import_meta_env_().CACHE_VERSION,
-{ id: 'CACHE_VERSION' })
+] = /** @type {be_sig_triple_T<false|string>} */
+id_be_sig_triple_(
+	'CACHE_VERSION',
+	()=>
+		typeof process === 'object' && import_meta_env_().CACHE_VERSION)
 export {
 	CACHE_VERSION$_ as CACHE_VERSION__,
 	CACHE_VERSION$_ as b__CACHE_VERSION,

package/all/NODE_ENV/index.js

@@ -1,13 +1,14 @@
 /// <reference types="ctx-core" />
-import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { id_be_sig_triple_ } from '../be_sig_triple/index.js'
 import { import_meta_env_ } from '../import_meta_env/index.js'
 export const [
 	NODE_ENV$_,
 	NODE_ENV_,
 	NODE_ENV__set,
-] = be_sig_triple_(()=>
-	import_meta_env_().NODE_ENV,
-{ id: 'NODE_ENV' })
+] = id_be_sig_triple_(
+	'NODE_ENV',
+	()=>
+		import_meta_env_().NODE_ENV)
 export {
 	NODE_ENV$_ as NODE_ENV__,
 	NODE_ENV$_ as b__NODE_ENV,

package/all/VERSION/index.js

@@ -1,12 +1,13 @@
-import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { id_be_sig_triple_ } from '../be_sig_triple/index.js'
 import { import_meta_env_ } from '../import_meta_env/index.js'
 export const [
 	VERSION$_,
 	VERSION_,
 	VERSION__set,
-] = be_sig_triple_(()=>
-	typeof process === 'object'
+] = id_be_sig_triple_(
+	'VERSION',
+	()=>
+		typeof process === 'object'
 		&& (import_meta_env_().VERSION || import_meta_env_().HEROKU_SLUG_COMMIT)
-		|| Math.random().toString(),
-{ id: 'VERSION' })
+		|| Math.random().toString())
 export { VERSION$_ as VERSION__ }

package/all/be/index.d.ts

@@ -9,3 +9,30 @@ export declare function be<
 	config:be_config_T<ns_T>
 ):val_T
 export { be as b, }
+export declare function id_be<
+	val_T extends NonNullable<unknown>,
+	ctx_T extends wide_ctx_T<''> = wide_ctx_T<''>,
+>(
+	ctx:ctx_T,
+	id:string,
+	val_:be__val__new_T<val_T, '', ctx_T>,
+):val_T
+export declare function ns_be<
+	val_T extends NonNullable<unknown>,
+	ns_T extends string = '',
+	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
+>(
+	ctx:ctx_T,
+	ns:ns_T,
+	val_:be__val__new_T<val_T, ns_T, ctx_T>,
+):val_T
+export declare function ns_id_be<
+	val_T extends NonNullable<unknown>,
+	ns_T extends string = '',
+	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
+>(
+	ctx:ctx_T,
+	ns:ns_T,
+	id:string,
+	val_:be__val__new_T<val_T, ns_T, ctx_T>,
+):val_T

package/all/be/index.js

@@ -10,3 +10,28 @@ export function be(ctx, val_, config) {
 	return be_(val_, config)(ctx)
 }
 export { be as b, }
+/**
+ * @param {ctx_T}ctx
+ * @param {string}id
+ * @param {be__val__new_T}val_
+ */
+export function id_be(ctx, id, val_) {
+	return be(ctx, val_, { id })
+}
+/**
+ * @param {ctx_T}ctx
+ * @param {string}ns
+ * @param {be__val__new_T}val_
+ */
+export function ns_be(ctx, ns, val_) {
+	return be(ctx, val_, { ns })
+}
+/**
+ * @param {ctx_T}ctx
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T}val_
+ */
+export function ns_id_be(ctx, ns, id, val_) {
+	return be(ctx, val_, { ns, id })
+}

package/all/be/index.test.ts

@@ -1,8 +1,8 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
-import { be_ } from '../be_/index.js'
-import { ctx__new } from '../ctx/index.js'
-import { be } from './index.js'
+import { be_, id_be_, ns_be_, ns_id_be_ } from '../be_/index.js'
+import { ctx__new, ns_ctx__new } from '../ctx/index.js'
+import { be, id_be, ns_be, ns_id_be } from './index.js'
 test('be|s|BeMap', ()=>{
 	const ctx = ctx__new()
 	let incrementer_num = 0
@@ -12,10 +12,54 @@ test('be|s|BeMap', ()=>{
 	{ id: 'root_' })
 	const child = be(ctx, ctx=>
 		root_(ctx) + incrementer(),
-	{ id: 'child_' })
+	{ id: 'child' })
 	equal(root_(ctx), 1)
 	equal(ctx.s[''].get('root_')![0], 1)
 	equal(child, 3)
-	equal(ctx.s[''].get('child_')![0], 3)
+	equal(ctx.s[''].get('child')![0], 3)
+})
+test('id_be|s|BeMap', ()=>{
+	const ctx = ctx__new()
+	let incrementer_num = 0
+	const incrementer = ()=>++incrementer_num
+	const root_ = id_be_(
+		'root_',
+		()=>incrementer())
+	const child = id_be(ctx, 'child', ctx=>
+		root_(ctx) + incrementer())
+	equal(root_(ctx), 1)
+	equal(ctx.s[''].get('root_')![0], 1)
+	equal(child, 3)
+	equal(ctx.s[''].get('child')![0], 3)
+})
+test('ns_be|s|BeMap', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let incrementer_num = 0
+	const incrementer = ()=>++incrementer_num
+	const root_ = ns_be_(
+		'test_ns',
+		()=>incrementer())
+	const child = ns_be(ctx, 'test_ns', ctx=>
+		root_(ctx) + incrementer())
+	equal(root_(ctx), 1)
+	equal(ctx.s.test_ns.get(root_)![0], 1)
+	equal(child, 3)
+	const child_id = Array.from(ctx.s.test_ns.keys()).find(id=>id!==root_)!
+	equal(ctx.s.test_ns.get(child_id)![0], 3)
+})
+test('ns_id_be|s|BeMap', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let incrementer_num = 0
+	const incrementer = ()=>++incrementer_num
+	const root_ = ns_id_be_(
+		'test_ns',
+		'root_',
+		()=>incrementer())
+	const child = ns_id_be(ctx, 'test_ns', 'child', ctx=>
+		root_(ctx) + incrementer())
+	equal(root_(ctx), 1)
+	equal(ctx.s.test_ns.get('root_')![0], 1)
+	equal(child, 3)
+	equal(ctx.s.test_ns.get('child')![0], 3)
 })
 test.run()

package/all/rmemo/index.d.ts

@@ -44,13 +44,13 @@ export type memo_T<val_T, E = unknown> = (()=>val_T)&{
 		add_def_a1?:rmemo_add_def_T<val_T, E>[]
 	):memo_T<_val_T, E>
 	val:val_T
-	readonly a?:rmemo_a_T
-	readonly b:rmemo_add_def_T<val_T, E>[]
-	readonly d:()=>val_T
-	readonly l:number
-	readonly r:rmemo_r_T[]
-	readonly u:rmemo_T<unknown>[]
-	readonly t:rmemo_T<unknown>[]
+	readonly a:unknown
+	readonly b:unknown
+	readonly d:unknown
+	readonly l:unknown
+	readonly r:unknown
+	readonly u:unknown
+	readonly t:unknown
 }&E
 interface _circular_memo_T extends memo_T<_circular_memo_T> {
 }

package/all/rmemo/index.test.ts

@@ -199,9 +199,9 @@ test('rmemo|add|has strong reference to the return value', ()=>{
 	equal(num$.a, undefined)
 	equal(add_arg_aa, [])
 	equal(num$(), undefined)
-	equal(num$.a![0], memo)
+	equal((<any>num$.a)![0], memo)
 	equal(memo!.val, 99)
-	equal((num$.a![0] as memo_T<number>).val, 99)
+	equal((<memo_T<number>>(<any>num$.a)![0]).val, 99)
 	equal(add_arg_aa, [[num$, undefined]])
 })
 test('rmemo|add|notified if sig is set before read', ()=>{

package/all/wanimato/index.d.ts

@@ -1,7 +1,7 @@
 import type { nullish } from '../nullish/index.js'
-import type { sig_T } from '../rmemo/index.js'
+import type { memo_T } from '../rmemo/index.js'
 export declare function wanimato__new<E extends Element>(
-	$:sig_T<wanimato_T|nullish>,
+	$:memo_T<wanimato_T>|memo_T<wanimato_T|nullish>,
 	el:E,
 	animation_:(el:E)=>Animation
 ):wanimato_T

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "7.0.1",
+  "version": "7.1.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -430,7 +430,7 @@
       "import": {
         "./web_animation": "{ memo_, wanimato__new }"
       },
-      "limit": "707 B"
+      "limit": "706 B"
     }
   ],
   "scripts": {