@dereekb/dbx-components-mcp 13.36.0 → 13.38.0

package/generated/dereekb-firebase.model-snapshot-fields.mcp.generated.json

@@ -92,6 +92,46 @@
       ],
       "example": "fields: {\n  payload: firestorePassThroughField<MyType>()\n}"
     },
+    {
+      "slug": "optional-firestore-passthrough-json-field",
+      "name": "optionalFirestorePassthroughJsonField",
+      "kind": "factory",
+      "category": "object",
+      "module": "@dereekb/firebase",
+      "subpath": "common/firestore/snapshot/snapshot.field",
+      "signature": "optionalFirestorePassthroughJsonField(config?: OptionalFirestorePassthroughJsonFieldConfig<T>): FirestoreModelFieldMapFunctionsConfig<Maybe<T>, Maybe<T>>",
+      "description": "Creates a field mapping configuration for an optional object field that is stored as-is, aside from\nthe values the filter strips out on the way in.\n\nThis is the field for json a converter should not model: a third-party api response, a request config\nwhose parameters the vendor extends without warning, an sdk-shaped payload. A strict converter would\nsilently drop whatever it does not name; this one keeps everything.\n\nThe one thing it does not keep is a value Firestore rejects. Firestore refuses an explicit `undefined`\noutright — one absent optional field anywhere in the payload fails the whole write — and such a value\nis exactly what assembling json from `Maybe` inputs produces (a usage object built from whichever\ntoken counts a response happened to report, a config a caller spread a `Maybe` into). Solved per-writer\nit has to be remembered at every call site; solved here it cannot be forgotten.\n\nThe filtering is RECURSIVE, since json of this kind is nested and its interior is just as capable of\ncarrying an `undefined` as its top level. Non-plain values are retained by reference, so a `Date` (or\na `Timestamp`, or a `DocumentReference`) survives the copy intact.\n\nFiltering happens on WRITE only. Reads are the plain passthrough — no copy, no traversal — since data\nthat came out of Firestore cannot contain the values being filtered in the first place.\n\nA top-level `null` still clears the field: {@link optionalFirestoreField} short-circuits `x == null`\nahead of the transform, so `update({ myField: null })` is untouched by this.",
+      "optional": true,
+      "params": [
+        {
+          "name": "config",
+          "type": "OptionalFirestorePassthroughJsonFieldConfig<T>",
+          "description": "- Filtering and storage configuration. Defaults to stripping `undefined` values at every depth.",
+          "optional": true
+        }
+      ],
+      "returns": "A field mapping configuration for optional passthrough json values.",
+      "tags": [
+        "json",
+        "passthrough",
+        "object",
+        "raw",
+        "optional",
+        "undefined",
+        "filter",
+        "recursive",
+        "factory",
+        "firestore",
+        "field",
+        "optionalfirestorepassthroughjsonfield"
+      ],
+      "example": "fields: {\n  // { model: 'm', temperature: undefined, provider: { only: ['openai'], sort: undefined } }\n  // stores as { model: 'm', provider: { only: ['openai'] } }\n  config: optionalFirestorePassthroughJsonField<MyVendorConfig>(),\n  // store null rather than an empty object when nothing survives the filtering\n  usage: optionalFirestorePassthroughJsonField<MyVendorUsage>({ filterEmptyValues: true, dontStoreIfEmpty: true })\n}",
+      "relatedSlugs": [
+        "optional-firestore-field",
+        "firestore-pass-through-field",
+        "firestore-sub-object"
+      ]
+    },
     {
       "slug": "firestore-string",
       "name": "firestoreString",

package/generated/dereekb-util.utils.mcp.generated.json

@@ -7081,6 +7081,88 @@
         "object-keys-equality-comparator-function"
       ]
     },
+    {
+      "slug": "copy-value-deep-function",
+      "name": "copyValueDeepFunction",
+      "kind": "factory",
+      "category": "object",
+      "module": "@dereekb/util",
+      "subpath": "object/object.copy",
+      "signature": "copyValueDeepFunction(config?: Maybe<CopyValueDeepConfig>): CopyValueDeepFunction",
+      "description": "Creates a reusable {@link CopyValueDeepFunction}.\n\nPlain objects and arrays are copied recursively. Every other value is retained by reference:\nprimitives have nothing to copy, and a `Date`/`Map`/`Set`/class instance is a value in its own right,\nnot a bag of keys to rebuild — copying one key-by-key would replace a `Date` with `{}`. This is what\nmakes the function safe to use on data that carries such instances (a Firestore `Timestamp`, a\n`DocumentReference`) alongside plain json.\n\nThe root value itself is never filtered — only the values found within an object or array are, since\nthe filter is a decision about a key/value pair. A root `undefined` therefore copies to `undefined`.\n\nRepeated and cyclical references are tracked, so a value referenced twice is copied once and a cycle\nterminates rather than overflowing the stack.",
+      "params": [
+        {
+          "name": "config",
+          "type": "Maybe<CopyValueDeepConfig>",
+          "description": "- Filter, array handling, and transform configuration. Defaults to removing `undefined` values.",
+          "optional": true
+        }
+      ],
+      "returns": "Recursively copies any input value.",
+      "tags": [
+        "object",
+        "copy",
+        "clone",
+        "deep",
+        "recursive",
+        "filter",
+        "transform",
+        "undefined",
+        "factory",
+        "value",
+        "function",
+        "copyvaluedeepfunction"
+      ],
+      "example": "// remove undefined values at any depth\nconst copyFn = copyValueDeepFunction();\ncopyFn({ a: 1, b: undefined, c: { d: undefined, e: [1, undefined] } });\n// { a: 1, c: { e: [1] } }\n\n// remove null and undefined values, and prune anything left empty\nconst copyCleanFn = copyValueDeepFunction({ filter: KeyValueTypleValueFilter.NULL, filterEmptyValues: true });\ncopyCleanFn({ a: 1, b: { c: null } });\n// { a: 1 }",
+      "relatedSlugs": [
+        "copy-value-deep",
+        "filter-from-pojo-function",
+        "copy-object"
+      ]
+    },
+    {
+      "slug": "copy-value-deep",
+      "name": "copyValueDeep",
+      "kind": "function",
+      "category": "object",
+      "module": "@dereekb/util",
+      "subpath": "object/object.copy",
+      "signature": "copyValueDeep(value: T, config?: Maybe<CopyValueDeepConfig>): T",
+      "description": "Recursively copies a value, filtering values as it goes.\n\nSee {@link copyValueDeepFunction} for the copy/filter semantics. Prefer the factory when copying more\nthan one value with the same configuration.",
+      "params": [
+        {
+          "name": "value",
+          "type": "T",
+          "description": "- The value to copy.",
+          "optional": false
+        },
+        {
+          "name": "config",
+          "type": "Maybe<CopyValueDeepConfig>",
+          "description": "- Filter, array handling, and transform configuration. Defaults to removing `undefined` values.",
+          "optional": true
+        }
+      ],
+      "returns": "A recursive copy of the value.",
+      "tags": [
+        "object",
+        "copy",
+        "clone",
+        "deep",
+        "recursive",
+        "filter",
+        "transform",
+        "undefined",
+        "value",
+        "copyvaluedeep"
+      ],
+      "example": "copyValueDeep({ a: 1, b: { c: undefined } });\n// { a: 1, b: {} }",
+      "relatedSlugs": [
+        "copy-value-deep-function",
+        "filter-from-pojo",
+        "copy-object"
+      ]
+    },
     {
       "slug": "object-is-empty",
       "name": "objectIsEmpty",
@@ -7970,6 +8052,39 @@
         "maptoobject"
       ]
     },
+    {
+      "slug": "is-plain-object",
+      "name": "isPlainObject",
+      "kind": "function",
+      "category": "object",
+      "module": "@dereekb/util",
+      "subpath": "object/object",
+      "signature": "isPlainObject(value: unknown): value is Record<string, unknown>",
+      "description": "Checks whether the value is a \"plain\" object, meaning an object literal or an object created with a\nnull prototype.\n\nArrays, `Date`, `RegExp`, `Map`, `Set`, and class instances are NOT plain objects. This is the check\nto use before recursing into a value's keys: a class instance's keys are an implementation detail and\ncopying them key-by-key produces a lifeless imitation of the original (a `Date` becomes `{}`).",
+      "params": [
+        {
+          "name": "value",
+          "type": "unknown",
+          "description": "- The value to check.",
+          "optional": false
+        }
+      ],
+      "returns": "`true` if the value is an object literal or has a null prototype.",
+      "tags": [
+        "object",
+        "pojo",
+        "plain",
+        "literal",
+        "type-guard",
+        "check",
+        "is",
+        "isplainobject"
+      ],
+      "relatedSlugs": [
+        "object-has-no-keys",
+        "copy-value-deep"
+      ]
+    },
     {
       "slug": "copy-object",
       "name": "copyObject",

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@dereekb/dbx-components-mcp",
-  "version": "13.36.0",
+  "version": "13.38.0",
   "type": "module",
   "bin": {
     "dbx-components-mcp": "dbx-components-mcp.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "arktype": "^2.2.0",
     "ts-morph": "^21.0.0"
   },
   "peerDependencies": {
-    "@dereekb/dbx-cli": "13.36.0",
-    "@dereekb/util": "13.36.0"
+    "@dereekb/dbx-cli": "13.38.0",
+    "@dereekb/util": "13.38.0"
   }
 }