ctx-core 5.0.1 → 5.2.0

package/all/CACHE_VERSION/index.d.ts

@@ -0,0 +1,10 @@
+import type { be_sig_triple_T } from 'rmemo'
+export declare const [
+	CACHE_VERSION$_,
+	CACHE_VERSION_,
+	CACHE_VERSION__set,
+]:be_sig_triple_T<false|string>
+export {
+	CACHE_VERSION$_ as CACHE_VERSION__,
+	CACHE_VERSION$_ as b__CACHE_VERSION,
+}

package/all/CACHE_VERSION/index.js

@@ -0,0 +1,14 @@
+/// <reference types="ctx-core" />
+import { 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' })
+export {
+	CACHE_VERSION$_ as CACHE_VERSION__,
+	CACHE_VERSION$_ as b__CACHE_VERSION,
+}

package/all/NODE_ENV/index.d.ts

@@ -0,0 +1,10 @@
+import type { be_sig_triple_T } from 'rmemo'
+export declare const [
+	NODE_ENV$_,
+	NODE_ENV_,
+	NODE_ENV__set,
+]:be_sig_triple_T<string>
+export {
+	NODE_ENV$_ as NODE_ENV__,
+	NODE_ENV$_ as b__NODE_ENV,
+}

package/all/NODE_ENV/index.js

@@ -0,0 +1,14 @@
+/// <reference types="ctx-core" />
+import { 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' })
+export {
+	NODE_ENV$_ as NODE_ENV__,
+	NODE_ENV$_ as b__NODE_ENV,
+}

package/all/Request/index.js

@@ -1,2 +1,3 @@
-/** @type {import('../Request/index.d.ts').Request} */
+/// <reference types="../index.d.ts" />
+/** @type {Request} */
 export const { Request, RequestInit } = globalThis

package/all/Response/index.js

@@ -1,2 +1,2 @@
-/** @type {import('../Response/index.d.ts').Response} */
+/** @type {import('../Response/index.d.ts').Response}Response */
 export const { Response } = globalThis

package/all/VERSION/index.d.ts

@@ -0,0 +1,7 @@
+import type { be_sig_triple_T } from 'rmemo'
+export declare const [
+	VERSION$_,
+	VERSION_,
+	VERSION__set,
+]:be_sig_triple_T<string>
+export { VERSION$_ as VERSION__ }

package/all/VERSION/index.js

@@ -0,0 +1,12 @@
+import { 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'
+		&& (import_meta_env_().VERSION || import_meta_env_().HEROKU_SLUG_COMMIT)
+		|| Math.random().toString(),
+{ id: 'VERSION' })
+export { VERSION$_ as VERSION__ }

package/all/add/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../nullish/index.d.ts').nullish} */
+/// <reference types="../nullish/index.d.ts" />
 /**
  * Adds the arguments
  * @param {readonly (number|nullish)[]|nullish}numerator_a

package/all/all_union_a/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../add/index.js').all_union_a_T} */
+/// <reference types="../add/index.d.ts" />
 /**
  * @return {(a:all_union_a_T)=>all_union_a_T}
  * @see {@link https://stackoverflow.com/questions/60131681/make-sure-array-has-all-types-from-a-union/75418615#75418615}

package/all/and/index.js

@@ -1,8 +1,9 @@
+/// <reference types="../a_nowrap/index.d.ts" />
 import { wrap_a_ } from '../wrap_a/index.js'
 import { wrap_concat } from '../wrap_concat/index.js'
 /**
  * Returns the first falsy or last item in `a_nowrap`.
- * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @param {a_nowrap_T}a_nowrap
  * @returns {unknown}
  */
 export function and(a_nowrap) {

package/all/andand_or/index.js

@@ -1,5 +1,6 @@
+/// <reference types="../andand/index.d.ts" />
 import { andand } from '../andand/index.js'
-/** @typedef {import('../andand/index.js').andand_key_T} */
+/** @typedef {andand_key_T} */
 /**
  * Returns `andand(obj, name_a) || or_fn(obj, val)`
  * @param {unknown|null}obj

package/all/andandfn/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../andand/index.js').andand_key_T} */
+/// <reference types="../andand/index.d.ts" />
+/// <reference types="../andandfn/index.d.ts" />
 /**
  * Applies `&&` to a chain of property name or function with return value from `obj`.
  * @param {unknown}obj
@@ -24,11 +25,11 @@ export function andandfn(obj, ...name_a) {
 	return out_value
 }
 export { andandfn as andand__fn, }
-/** @typedef {import('../andand/index.d.ts').andand_key_T} */
+/** @typedef {andand_key_T} */
 /**
  * Returns a function that calls `andand_(obj, ...name_a)`
  * @param {andand_key_T}name_a
- * @returns {import('../andandfn').andandfn_T}
+ * @returns {andandfn_T}
  */
 export function andandfn_(...name_a) {
 	return (obj)=>andandfn(obj, ...name_a)

package/all/apply/index.js

@@ -1,9 +1,11 @@
-/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/// <reference types="../bind_call/index.d.ts" />
+/// <reference types="../call/index.d.ts" />
+/** @typedef {call_fn_T} */
 /**
  * Returns function that applies in_arg_a with ...fn_arg_a
  * @param {call_fn_T}fn
  * @param {unknown[]}[in_arg_a]
- * @returns {import('../bind_call').bind_call_T}
+ * @returns {bind_call_T}
  */
 export function apply_(fn, in_arg_a = []) {
 	return (...fn_arg_a)=>fn(...[

package/all/arg_a__pick/index.d.ts

@@ -0,0 +1,6 @@
+import type { param_dfn_T } from '../param_dfn/index.js'
+export declare function arg_a__pick(
+	arg_a:string[],
+	...param_dfn_a:param_dfn_T[]
+):string[]
+export { arg_a__pick as pick_arg_a1, }

package/all/arg_a__pick/index.js

@@ -0,0 +1,16 @@
+/// <reference types="../_types/index.js" />
+import { flag_r__pick } from '../flag_r__pick/index.js'
+import { flag_r_arg_a_ } from '../flag_r_arg_a/index.js'
+/**
+ * @param {string[]}arg_a
+ * @param {param_dfn_T}param_dfn_a
+ * @returns {string[]}
+ */
+export function arg_a__pick(
+	arg_a,
+	...param_dfn_a
+) {
+	const pick_flag_R = flag_r__pick(arg_a, ...param_dfn_a)
+	return flag_r_arg_a_(pick_flag_R, arg_a)
+}
+export { arg_a__pick as pick_arg_a1, }

package/all/arg_i0_a/index.js

@@ -1,9 +1,10 @@
+/// <reference types="../slice_arg_spread_a/index.d.ts" />
 import { slice_arg_spread_a_ } from '../slice_arg_spread_a/index.js'
-/** @typedef {import('../slice_arg_spread_a_/index.js').slice_arg_spread_a__arg__T} */
+/** @typedef {slice_arg_spread_a__arg__T} */
 /**
  * Returns a function that calls fn passing only the first argument.
  * @param {slice_arg_spread_a__arg__T}fn
- * @returns {import('../slice_arg_spread_a_').slice_arg_spread_a___ret_T}
+ * @returns {slice_arg_spread_a___ret_T}
  */
 export function arg_i0_a(fn) {
 	return slice_arg_spread_a_(fn, 0, 1)

package/all/assign_fn_key_a/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../assign_fn_key_a/index.js').fn_key_a_tuple_T} */
+/// <reference types="../assign_fn_key_a/index.d.ts" />
 /**
  * Assigns to an obj array of keys the return value of function in key_a_fn_aa.
  * @param {object}obj

package/all/bad_gateway/index.js

@@ -1,6 +1,7 @@
+/// <reference types="../error_o/index.d.ts" />
 import { assign } from '../assign/index.js'
 import { HttpError } from '../http_error/index.js'
-/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+/** @typedef {argument__error_o_T} */
 export const bad_gateway__default__message = 'Bad Gateway'
 /**
  * @param {string}[message]

package/all/bad_request/index.js

@@ -1,6 +1,6 @@
+/// <reference types="../error_o/index.d.ts" />
 import { assign } from '../assign/index.js'
 import { HttpError } from '../http_error/index.js'
-/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
 export const bad_request__default__message = 'Bad Request'
 /**
  * @param {string}[message]

package/all/be/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../be_/index.d.ts" />
 import { be_ } from '../be_/index.js'
 /**
- * @param {import('../be_/index.js').Ctx}ctx
- * @param {import('../be_/index.js').be__val__new_T}val_
+ * @param {Ctx}ctx
+ * @param {be__val__new_T}val_
  * @returns {NonNullable<unknown>}
  */
 export function be(ctx, val_) {

package/all/be_/index.d.ts

@@ -37,6 +37,12 @@ export declare function ctx__delete<
 	be_OR_id:Be<unknown, ns_T, ctx_T>|string|symbol,
 	ns?:string
 ):void
+/**
+ * Clear all BeMap values by running ctx__delete on all stored Be functions.
+ * This behavior can be used in conjunction with ondelete_be_ to run the ondelete callbacks
+ * on all of the ondelete_be functions.
+ */
+export declare function ctx__clear(ctx:Ctx):void
 export declare function be__has_<
 	ns_T extends string = '',
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
@@ -50,11 +56,27 @@ export declare function be__val_<
 	ns_T extends string = '',
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
 >(be_OR_id:Be<val_T, ns_T, ctx_T>|string, ctx:ctx_T, ns?:ns_T):val_T|unknown|null
-export declare type Be<
+export declare function ondelete_be_<
+	val_T,
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+>(
+	val__new:ondelete_be__val__new_T<val_T, ns_T, ctx_T>,
+	config?:be_config_T<ns_T>
+):ondelete_Be<val_T, ns_T, ctx_T>
+export type Be<
 	val_T,
 	ns_T extends string = '',
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
 > = ((ctx:ctx_T)=>val_T)&be_o_T<val_T, ns_T, ctx_T>
+export type ondelete_Be<
+	val_T,
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+> = ((ctx:ctx_T)=>val_T)&be_o_T<val_T, ns_T, ctx_T>&{
+	ondelete(cb:(val:val_T, ctx:ctx_T, be:Be<val_T, ns_T, ctx_T>)=>void):void
+	d():void
+}
 export type be_o_T<
 	val_T,
 	ns_T extends string = '',
@@ -70,14 +92,27 @@ export type be_config_T<ns_T extends string = string> = {
 }
 export type BeMap<
 	ns_T extends string = ''
-> = Map<Be<unknown, ns_T, Ctx_wide_T<ns_T>>|string|symbol, unknown>
+> =
+	Map<
+		Be<unknown, ns_T, Ctx_wide_T<ns_T>>|string|symbol,
+		[unknown, Be<unknown, ns_T, Ctx_wide_T<ns_T>>, Ctx_wide_T<ns_T>]
+	>
 export type BeMapO<ns_union_T extends string> =
 	{ [K in ns_union_T]:BeMap<K> }
-export declare type be__val__new_T<
+export type be__val__new_T<
 	val_T,
 	ns_T extends string = '',
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 > = (ctx:ctx_T, be:Be<val_T, ns_T, ctx_T>)=>val_T
+export type ondelete_be__val__new_T<
+	val_T,
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>
+> =
+	(
+		ctx:ctx_T,
+		be:ondelete_Be<val_T, ns_T, ctx_T>
+	)=>val_T
 export type Ctx<ns_T extends string = string> = Readonly<{
 	s:Ctx_s_T<ns_T>
 	is_ctx:true

package/all/be_/index.js

@@ -17,13 +17,23 @@ export function be_(val__new, config) {
 			// ~ 30 B
 			if (!be_map) throw Error('ctx_no_ns: \'' + be.ns + '\'')
 		/* @endif */
-		if (be_map.has(be.id)) return be_map.get(be.id)
-		// circular dependency state
-		// if val__new calls this be before returning, 'cir' will be the value of this be
-		// 'cir' is used instead of 'circular' to reduce the payload by a few bytes
-		be_map.set(be.id, 'cir')
-		be_map.set(be.id, val__new(ctx, be))
-		return be_map.get(be.id)
+		// config is not used anymore so reusing to reduce bundle size
+		config = be_map.get(be.id)
+		if (config) return config[0]
+		/* @if DEBUG **
+			// 5-11 B
+			// circular dependency state
+			// if val__new calls this be before returning, 'cir' will be the value of this be
+			// 'cir' is used instead of 'circular' to reduce the payload by a few bytes
+			config = ['cir', ctx, be]
+			be_map.set(be.id, config)
+			config[0] = val__new(ctx, be)
+		/* @endif */
+		/* @if !DEBUG */
+		config = [val__new(ctx, be), ctx, be]
+		be_map.set(be.id, config)
+		/* @endif */
+		return config[0]
 	}
 	be.id = config?.id ?? be
 	be.ns = config?.ns ?? ''
@@ -57,7 +67,13 @@ export function ctx__set(
 	val,
 	ns = be_OR_id.ns ?? ''
 ) {
-	ctx.s[ns].set(be_OR_id.id ?? be_OR_id, val)
+	let state =
+		ctx.s[ns].get(be_OR_id.id ?? be_OR_id)
+		?? [val, be_OR_id.id ?? be_OR_id, ctx]
+	// ondelete
+	if (state[1] !== (be_OR_id.id ?? be_OR_id)) state[1].d?.(...state)
+	state[0] = val
+	ctx.s[ns].set(state[1], state)
 }
 /**
  * @param {Ctx}ctx
@@ -69,11 +85,22 @@ export function ctx__delete(
 	be_OR_id,
 	ns = be_OR_id.ns ?? ''
 ) {
-	if (ns != null) {
-		ctx.s[ns].delete(be_OR_id.id ?? be_OR_id)
-	} else {
-		for (let _source in ctx.s) {
-			ctx.s[_source].delete(be_OR_id.id ?? be_OR_id)
+	let state = ctx.s[ns].get(be_OR_id.id ?? be_OR_id)
+	if (state) {
+		state[2].d?.(...state)
+		ctx.s[ns].delete(state[2].id)
+	}
+}
+/**
+ * Clear all BeMap values by running ctx__delete on all stored Be functions.
+ * This behavior can be used in conjunction with ondelete_be_ to run the ondelete callbacks
+ * on all of the ondelete_be functions.
+ * @param {Ctx}ctx
+ */
+export function ctx__clear(ctx) {
+	for (let ns in ctx.s) {
+		for (let id of ctx.s[ns].keys()) {
+			ctx__delete(ctx, id)
 		}
 	}
 }
@@ -103,5 +130,16 @@ export function be_map__find(be_or_id, ctx, ns = be_or_id.ns ?? '') {
  * @private
  */
 export function be__val_(be_or_id, ctx, ns) {
-	return be_map__find(be_or_id, ctx, ns)?.get?.(be_or_id.id ?? be_or_id)
+	return be_map__find(be_or_id, ctx, ns)?.get?.(be_or_id.id ?? be_or_id)?.[0]
+}
+export function ondelete_be_(val__new, config) {
+	let be = be_(val__new, config)
+	let ondelete_cb_a = []
+	be.ondelete = cb=>ondelete_cb_a.push(cb)
+	be.d = (...state)=>{
+		for (let ondelete_cb of ondelete_cb_a) {
+			ondelete_cb(...state)
+		}
+	}
+	return be
 }