ctx-core 3.3.3 → 4.1.0

package/README.md

@@ -1,2 +1,5 @@
 # ctx-core
 ctx-core core (ctx-core^2) libraries...used by @ctx-core/* libraries. The development monorepo has been moved to @ctx-core/dev
+
+## macropackage
+

package/all/all_union_a/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../add/index.js').all_union_a_T}all_union_a_T */
+/** @typedef {import('../add/index.js').all_union_a_T} */
 /**
  * @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/andand_or/index.js

@@ -1,5 +1,5 @@
 import { andand } from '../andand/index.js'
-/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.js').andand_key_T} */
 /**
  * Returns `andand(obj, name_a) || or_fn(obj, val)`
  * @param {unknown|null}obj

package/all/andandfn/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.js').andand_key_T} */
 /**
  * Applies `&&` to a chain of property name or function with return value from `obj`.
  * @param {unknown}obj
@@ -24,7 +24,7 @@ export function andandfn(obj, ...name_a) {
 	return out_value
 }
 export { andandfn as andand__fn, }
-/** @typedef {import('../andand/index.d.ts').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.d.ts').andand_key_T} */
 /**
  * Returns a function that calls `andand_(obj, ...name_a)`
  * @param {andand_key_T}name_a

package/all/arg_i0_a/index.js

@@ -1,5 +1,5 @@
 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}slice_arg_spread_a__arg__T */
+/** @typedef {import('../slice_arg_spread_a_/index.js').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

package/all/bad_credentials/index.js

@@ -1,6 +1,6 @@
 import { assign } from '../assign/index.js'
 import { HttpError } from '../http_error/index.js'
-/** @typedef {import('./index.d.ts').argument__bad_credentials_error_o_T}argument__bad_credentials_error_o_T */
+/** @typedef {import('./index.d.ts').argument__bad_credentials_error_o_T} */
 export const bad_credentials__default__message = 'Unauthorized'
 /**
  * @param {string}[message]

package/all/be/index.d.ts

@@ -1,5 +1,5 @@
-import type { be__val__T, Ctx } from '../be_/index.js'
+import type { be__val__new_T, Ctx } from '../be_/index.js'
 export declare function be<
 	Out extends NonNullable<unknown>
->(ctx:Ctx, key:string, val_:be__val__T<Out>):Out
+>(ctx:Ctx, val_:be__val__new_T<Out>):Out
 export { be as b, }

package/all/be/index.js

@@ -1,11 +1,10 @@
 import { be_ } from '../be_/index.js'
 /**
  * @param {import('../be_/index.js').Ctx}ctx
- * @param {string}key
- * @param {import('../be_/index.js').be__val__T}val_
+ * @param {import('../be_/index.js').be__val__new_T}val_
  * @returns {NonNullable<unknown>}
  */
-export function be(ctx, key, val_) {
-	return be_(key, val_)(ctx)
+export function be(ctx, val_) {
+	return be_(val_)(ctx)
 }
 export { be as b, }

package/all/be_/index.d.ts

@@ -1,124 +1,80 @@
 export declare const pending_symbol:unique symbol
 export declare function globalThis__be_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
-export declare function globalThis__be_<
-	Val,
-	ctx_T extends Ctx = Ctx
->(
-	id:string,
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
+>(val_:be__val__new_T<val_T, ctx_T>):Be<val_T, ctx_T>
 /**
  * Auto-memoization function for the Ctx.
  *
- * Returns a function to ensure that a member id is defined on a ctx object,
- * otherwise it creates the value using the val_ factory function.
+ * Returns a function to ensure that a member id is defined on a Ctx,
+ * otherwise it caches & uses the return value of val__new.
  */
 export declare function be_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
-export declare function be_<
-	Val,
+>(val__new:be__val__new_T<val_T, ctx_T>, config?:be_config_T):Be<val_T, ctx_T>
+export type be___T<
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	id:string,
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
-export {
-	be_ as _be,
-	be_ as b_,
-	be_ as _b,
-}
+> = typeof be_<val_T, ctx_T>
 export declare function be__is_source_<
 	ctx_T extends Ctx = Ctx
 >(be:Be<unknown>):(map_ctx:MapCtx, ctx:ctx_T)=>boolean
 export declare function source__map_ctx_<
 	ctx_T extends Ctx = Ctx
->(ctx:Ctx, is_source_:is_source__T):MapCtx
-export declare function be__set<
-	Val,
-	ctx_T extends Ctx = Ctx
->(
-	be:Be<Val>,
-	ctx:ctx_T,
-	val:Val
-):void
+>(ctx:ctx_T, is_source_:is_source__T):MapCtx
 export declare function ctx__set<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
 	ctx:ctx_T,
-	be_OR_id:Be<Val>|string|symbol,
-	val:Val,
+	be_OR_id:Be<val_T>|string|symbol,
+	val:val_T,
 	is_source_?:is_source__T
 ):void
-export declare function be__delete<
-	Val,
-	ctx_T extends Ctx = Ctx
->(
-	be:Be<Val>,
-	ctx:ctx_T
-):void
 export declare function ctx__delete<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
 	ctx:ctx_T,
-	be_OR_id:Be<Val>|string|symbol,
+	be_OR_id:Be<val_T>|string|symbol,
 	is_source_?:is_source__T
 ):void
 export declare function be__has_<
 	ctx_T extends Ctx = Ctx
 >(be_OR_id:Be<unknown>|string, ctx:ctx_T):boolean
-export declare function be__has__ctx_<
+export declare function be__ctx_<
 	ctx_T extends Ctx = Ctx
 >(be_OR_id:Be<unknown>|string, ctx:ctx_T):MapCtx
 export declare function be__val_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(be_OR_id:Be<Val>|string, ctx:ctx_T):Val|unknown|null
-export declare type MapCtx = Map<Be<unknown>|string|symbol, unknown>
-export interface NestedMapCtx extends Array<NestedMapCtx|MapCtx> {
-}
+>(be_OR_id:Be<val_T>|string, ctx:ctx_T):val_T|unknown|null
+export type MapCtx = Map<Be<unknown>|string|symbol, unknown>&{ is_ctx: true }
+export type NestedMapCtx = Array<NestedMapCtx|MapCtx>
 export type Ctx = MapCtx|NestedMapCtx
 export declare type Be<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = ((ctx:ctx_T, params?:be_params_T)=>Val)&{
+> = ((ctx:ctx_T)=>val_T)&{
+	is_be: true
 	id?:string
 }
+export type be_config_T = {
+	id?:string
+	is_source_?:is_source__T
+}
 export declare type be__return_T<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = Be<Val, ctx_T>
+> = Be<val_T, ctx_T>
 export declare type be_T<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = Be<Val, ctx_T>
-export declare type be__val__T<
-	Val,
+> = Be<val_T, ctx_T>
+export declare type be__val__new_T<
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = (ctx:ctx_T, be:Be<Val, ctx_T>, params?:be_params_T)=>Val
-export interface be__params_T {
-	is_source_?:is_source__T
-	expired_?:expired__T
-	be_?:typeof be_
-}
-export type be__opts_T = be__params_T
-export interface be_params_T {
-	force?:boolean
-}
-export type be_opts_T = be_params_T
+> = (ctx:ctx_T, be:Be<val_T, ctx_T>)=>val_T
 export type is_source__T = (map_ctx:MapCtx, ctx:Ctx)=>boolean
 export type expired__T = (ctx:Ctx)=>boolean

package/all/be_/index.js

@@ -1,125 +1,59 @@
 import { globalThis__prop__ensure } from '../globalThis__prop__ensure/index.js'
-export * from './debug.js'
-let be_M_is_source_ = globalThis.be_M_is_source_ ||= new WeakMap()
-/** @typedef {import('./index.d.ts').Be}Be */
-/** @typedef {import('./index.d.ts').Ctx}Ctx */
-/** @typedef {import('./index.d.ts').MapCtx}MapCtx */
-/** @typedef {import('./index.d.ts').be__params_T}be__params_T */
-/** @typedef {import('./index.d.ts').be__val__T}be__val__T */
-/** @typedef {import('./index.d.ts').is_source__T}is_source__T */
+/** @typedef {import('./index.d.ts').Be} */
+/** @typedef {import('./index.d.ts').be_} */
+/** @typedef {import('./index.d.ts').be_config_T} */
+/** @typedef {import('./index.d.ts').Ctx} */
+/** @typedef {import('./index.d.ts').MapCtx} */
+/** @typedef {import('./index.d.ts').be__val__new_T} */
+/** @typedef {import('./index.d.ts').is_source__T} */
 /**
  * Auto-memoization function for the Ctx.
  * Memoized on globalThis to allow packages being loaded multiple times, which can happen during bundling.
  *
  * Returns a function to ensure that a member id_OR_val_ is defined on a ctx object,
- * otherwise it creates the value using the val__OR_be__params factory function.
- * @param {string|be__val__T}id_OR_val_
- * @param {be__val__T|be__params_T}[val__OR_be__params]
- * @param {be__params_T}[be__params]
+ * otherwise it caches & uses the return value of val__new.
+ * @param {be__val__new_T}val__new
  * @returns {Be}
  * @private
  */
-export function globalThis__be_(
-	id_OR_val_,
-	val__OR_be__params,
-	be__params
-) {
-	return globalThis__prop__ensure(
-		Symbol.for(id_OR_val_),
-		()=>be_(
-			id_OR_val_,
-			val__OR_be__params,
-			be__params))
-}
+export function globalThis__be_(val__new) {
+	return globalThis__prop__ensure(Symbol.for(val__new), ()=>be_(val__new)) }
 /**
  * Auto-memoization function for the Ctx.
  *
  * Returns a function to ensure that a member id is defined on a Ctx,
- * otherwise it creates the value using the val_ factory function.
- * @param {string|be__val__T}id_OR_val__new
- * @param {be__val__T|be__params_T}[val__new_OR_be__params]
- * @param {be__params_T}[be__params]
+ * otherwise it caches & uses the return value of val__new.
+ * @param {be__val__new_T}val__new
+ * @param {be_config_T}[config]
  * @returns {Be}
  * @private
  */
-export function be_(
-	id_OR_val__new,
-	val__new_OR_be__params,
-	be__params
-) {
-	/** @type {string} */
-	let id
-	/** @type {be__val__T} */
-	let val__new
-	/** @type {is_source__T} */
-	let is_source_
-	/** @type {expired__T} */
-	let expired_
-	if (typeof id_OR_val__new === 'string') {
-		val__new = val__new_OR_be__params
-		id = id_OR_val__new
-	} else {
-		val__new = id_OR_val__new
-		be__params = val__new_OR_be__params
-	}
-	if (be__params) {
-		is_source_ = be__params.is_source_
-		expired_ = be__params.expired_
-	}
-	let be = (argv__ctx, params)=>{
-		be_.argv__debug?.(argv__ctx)
-		let saved__val = be__val_(be, argv__ctx)
-		if (
-			!params?.force
-			&& be__has_(be, argv__ctx)
-			&& !expired_?.(argv__ctx)
-		) {
-			return saved__val
-		}
-		let ctx = source__map_ctx_(argv__ctx, is_source_)
-		be_.source__debug?.(ctx)
-		let pending = ctx.get(Symbol.for('pending'))
-		if (!pending) {
-			pending = new Map
-			ctx.set(Symbol.for('pending'), pending)
-		}
-		be_.pending__debug?.(pending)
-		pending.set(be, id || be)
-		let val = val__new ? val__new(argv__ctx, be, params) : null
-		ctx.set(be, val)
-		if (id) {
-			ctx.set(id, val)
+export function be_(val__new, config) {
+	let be = argv__ctx=>{
+		let flat__argv__ctx = Array.isArray(argv__ctx) && argv__ctx.flat(Infinity)
+		let be__ctx =
+      flat__argv__ctx
+	      ? flat__argv__ctx.find(ctx=>ctx.has(be))
+	      : argv__ctx.has(be) && argv__ctx
+		if (!be__ctx) {
+			be__ctx =
+				flat__argv__ctx
+					? flat__argv__ctx.find(ctx=>!be.is_source_ || be.is_source_(ctx, argv__ctx))
+					: (!be.is_source_ || be.is_source_(argv__ctx, argv__ctx)) && argv__ctx
+			// circular dependency state
+			// if val__new calls this be before returning, Symbol('cir') will be the value of this be
+			// 'cir' is used instead of 'circular' to reduce the payload by a few bytes
+			be__ctx.set(be, Symbol('cir'))
+			be__ctx.set(be, val__new(argv__ctx, be))
+			if (be.id) be__ctx.set(be.id, be__ctx.get(be))
 		}
-		pending.delete(be)
-		return val
+		return be__ctx.get(be)
 	}
-	be_M_is_source_.set(be, is_source_)
-	be.id = id
+	be.id = config?.id
+	be.is_source_ = config?.is_source_
+	be.is_be = true
 	return be
 }
-export {
-	be_ as _be,
-	be_ as b_,
-	be_ as _b,
-}
-/**
- * @param {Be}be
- * @returns {is_source__T}
- * @private
- */
-export function be__is_source__(be) {
-	return be_M_is_source_.get(be)
-}
-/**
- * @param {Be}be
- * @param {Ctx}ctx
- * @param {unknown}val
- * @returns {unknown}
- * @private
- */
-export function be__set(be, ctx, val) {
-	ctx__set(ctx, be, val, be__is_source__(be))
-}
 /**
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
@@ -132,7 +66,7 @@ export function ctx__set(
 	ctx,
 	be_OR_id,
 	val,
-	is_source_
+	is_source_ = be_OR_id.is_source_
 ) {
 	let source__map_ctx = source__map_ctx_(ctx, is_source_)
 	if (source__map_ctx) {
@@ -143,18 +77,9 @@ export function ctx__set(
 		}
 	}
 }
-/**
- * @param {Be}be
- * @param {Ctx}ctx
- * @private
- */
-export function be__delete(be, ctx) {
-	ctx__delete(ctx, be)
-}
 /**
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
- * @param {is_source__T}[is_source_]
  */
 export function ctx__delete(
 	ctx,
@@ -181,7 +106,7 @@ export function ctx__delete(
  * @private
  */
 export function be__has_(be_or_id, argv__ctx) {
-	return Boolean(be__has__ctx_(be_or_id, argv__ctx))
+	return Boolean(be__ctx_(be_or_id, argv__ctx))
 }
 /**
  * @param {Be|string}be_or_id
@@ -189,17 +114,17 @@ export function be__has_(be_or_id, argv__ctx) {
  * @returns {MapCtx}
  * @private
  */
-export function be__has__ctx_(be_or_id, argv__ctx) {
+export function be__ctx_(be_or_id, argv__ctx) {
 	if (Array.isArray(argv__ctx)) {
-		for (let i = 0; i < argv__ctx.length; i++) {
-			const be__has__ctx = be__has__ctx_(be_or_id, argv__ctx[i])
-			if (be__has__ctx) return be__has__ctx
+		for (let ctx of argv__ctx) {
+			let be__ctx = be__ctx_(be_or_id, ctx)
+			if (be__ctx) return be__ctx
 		}
-		return null
 	} else {
-		return argv__ctx.has(be_or_id) ? argv__ctx : null
+		if (argv__ctx.has(be_or_id)) return argv__ctx
 	}
 }
+export { be__ctx_ as be__has__ctx_ }
 /**
  * @param {Be|string}be_or_id
  * @param {Ctx}argv__ctx
@@ -207,30 +132,22 @@ export function be__has__ctx_(be_or_id, argv__ctx) {
  * @private
  */
 export function be__val_(be_or_id, argv__ctx) {
-	if (Array.isArray(argv__ctx)) {
-		for (let i = 0; i < argv__ctx.length; i++) {
-			let ctx = argv__ctx[i]
-			const be__has__ctx = be__has__ctx_(be_or_id, ctx)
-			if (be__has__ctx) return be__has__ctx.get(be_or_id)
-		}
-	} else {
-		return argv__ctx.get(be_or_id)
-	}
+	let be__ctx = be__ctx_(be_or_id, argv__ctx)
+	if (be__ctx) return be__ctx.get(be_or_id)
 }
 /**
- * @param {Ctx}ctx
+ * @param {Ctx}argv__ctx
  * @param {is_source__T}is_source_
  * @returns {unknown}
  * @private
  */
-export function source__map_ctx_(ctx, is_source_) {
-	if (Array.isArray(ctx)) {
-		for (let i = 0; i < ctx.length; i++) {
-			let i_ctx = ctx[i]
-			let source__map_ctx = source__map_ctx_(i_ctx, is_source_)
+export function source__map_ctx_(argv__ctx, is_source_) {
+	if (Array.isArray(argv__ctx)) {
+		for (let ctx of argv__ctx) {
+			let source__map_ctx = source__map_ctx_(ctx, is_source_)
 			if (source__map_ctx) return source__map_ctx
 		}
-	} else if (!is_source_ || is_source_(/** @type {MapCtx} */ctx, ctx)) {
-		return ctx
+	} else if (!is_source_ || is_source_(/** @type {MapCtx} */argv__ctx, argv__ctx)) {
+		return argv__ctx
 	}
 }