@okf/ootils 1.45.0 → 1.47.0

package/dist/browser.d.mts

@@ -1334,6 +1334,21 @@ declare const processAuthorAndCommonFilters: (allTpls: any[], filterScopes: stri
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     }[];
 };
@@ -1463,6 +1478,7 @@ declare const _self_managed_buildDocHierarchyConfig: ({ combinedDocumentBlocks,
             filters: any[];
             rollups: any[];
             rollupDisplayMap: Record<string, string>;
+            childByParentId: Record<string, any>;
         }[];
     };
     target: {
@@ -1623,6 +1639,7 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                     filters: any[];
                     rollups: any[];
                     rollupDisplayMap: Record<string, string>;
+                    childByParentId: Record<string, any>;
                 }[];
             };
             target: {
@@ -1689,6 +1706,21 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     })[];
 } | null)[];
@@ -1973,8 +2005,39 @@ declare class BlockRegistry {
         comp: string;
         props?: any;
     }): boolean;
-    /** Check if a specific block has a specific capability. */
-    hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * Check if a specific block has a specific capability.
+     *
+     * Type-level by default (keyed off `compType`). Pass the block INSTANCE as the
+     * optional third arg to honour per-instance overrides — today the only one is
+     * the annotation kill-switch: an annotation-capable block type returns `false`
+     * for the `annotation` capability when the instance sets
+     * `props.annotations.disable: true` in its tpl config. All other capabilities
+     * (and the no-instance form) fall through to the plain type-level check, so
+     * existing 2-arg callers are unaffected.
+     */
+    hasCapability(compType: string, capability: keyof BlockCapabilities, block?: {
+        props?: any;
+    }): boolean;
+    /**
+     * Per-instance annotation kill-switch.
+     *
+     * A block type may be annotation-capable at the registry level (e.g.
+     * LexicalTextEditor has `capabilities.annotation === true`), but an individual
+     * block instance can be opted out of annotation entirely by setting
+     * `props.annotations.disable: true` in its tpl config. Generic and config-only:
+     * to stop annotation on any field, add that prop — no code change.
+     *
+     * The single home for this `props.annotations.disable` path (note: `annotations`
+     * plural, distinct from the legacy singular `annotation.enable`). Consumed
+     * internally by `hasCapability` and `getAnnotationEnabledBlocks`, and directly
+     * by consumers that must actively suppress annotation UI (e.g. the FE block
+     * generators forcing disableViewHighlights/disableCreateHighlights), where a
+     * type-level `false` isn't enough on its own.
+     */
+    isAnnotationDisabledForBlock(block: {
+        props?: any;
+    }): boolean;
     /**
      * Returns true if the block stores its value as an array (Mongo schema type is Array).
      * Useful for callers that need to know whether to query `valuePath.0` for existence
@@ -1996,7 +2059,15 @@ declare class BlockRegistry {
      * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
      * falls back to the legacy per-instance `props.annotation.enable` toggle.
      *
-     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     * Per-instance kill-switch: any block is excluded when its tpl config sets
+     * `props.annotations.disable: true`, regardless of type-level capability. This
+     * is the single, config-only way to turn off annotation for a specific field —
+     * and because this method is the central gate used across every repo, the
+     * switch applies everywhere (annotate UI, AI auto-annotation, explorer,
+     * chunking/anno sync, filters).
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is
+     * auto-enabled unless explicitly disabled on the instance.
      */
     getAnnotationEnabledBlocks(allBlocks: Array<{
         comp: string;

package/dist/browser.d.ts

@@ -1334,6 +1334,21 @@ declare const processAuthorAndCommonFilters: (allTpls: any[], filterScopes: stri
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     }[];
 };
@@ -1463,6 +1478,7 @@ declare const _self_managed_buildDocHierarchyConfig: ({ combinedDocumentBlocks,
             filters: any[];
             rollups: any[];
             rollupDisplayMap: Record<string, string>;
+            childByParentId: Record<string, any>;
         }[];
     };
     target: {
@@ -1623,6 +1639,7 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                     filters: any[];
                     rollups: any[];
                     rollupDisplayMap: Record<string, string>;
+                    childByParentId: Record<string, any>;
                 }[];
             };
             target: {
@@ -1689,6 +1706,21 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     })[];
 } | null)[];
@@ -1973,8 +2005,39 @@ declare class BlockRegistry {
         comp: string;
         props?: any;
     }): boolean;
-    /** Check if a specific block has a specific capability. */
-    hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * Check if a specific block has a specific capability.
+     *
+     * Type-level by default (keyed off `compType`). Pass the block INSTANCE as the
+     * optional third arg to honour per-instance overrides — today the only one is
+     * the annotation kill-switch: an annotation-capable block type returns `false`
+     * for the `annotation` capability when the instance sets
+     * `props.annotations.disable: true` in its tpl config. All other capabilities
+     * (and the no-instance form) fall through to the plain type-level check, so
+     * existing 2-arg callers are unaffected.
+     */
+    hasCapability(compType: string, capability: keyof BlockCapabilities, block?: {
+        props?: any;
+    }): boolean;
+    /**
+     * Per-instance annotation kill-switch.
+     *
+     * A block type may be annotation-capable at the registry level (e.g.
+     * LexicalTextEditor has `capabilities.annotation === true`), but an individual
+     * block instance can be opted out of annotation entirely by setting
+     * `props.annotations.disable: true` in its tpl config. Generic and config-only:
+     * to stop annotation on any field, add that prop — no code change.
+     *
+     * The single home for this `props.annotations.disable` path (note: `annotations`
+     * plural, distinct from the legacy singular `annotation.enable`). Consumed
+     * internally by `hasCapability` and `getAnnotationEnabledBlocks`, and directly
+     * by consumers that must actively suppress annotation UI (e.g. the FE block
+     * generators forcing disableViewHighlights/disableCreateHighlights), where a
+     * type-level `false` isn't enough on its own.
+     */
+    isAnnotationDisabledForBlock(block: {
+        props?: any;
+    }): boolean;
     /**
      * Returns true if the block stores its value as an array (Mongo schema type is Array).
      * Useful for callers that need to know whether to query `valuePath.0` for existence
@@ -1996,7 +2059,15 @@ declare class BlockRegistry {
      * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
      * falls back to the legacy per-instance `props.annotation.enable` toggle.
      *
-     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     * Per-instance kill-switch: any block is excluded when its tpl config sets
+     * `props.annotations.disable: true`, regardless of type-level capability. This
+     * is the single, config-only way to turn off annotation for a specific field —
+     * and because this method is the central gate used across every repo, the
+     * switch applies everywhere (annotate UI, AI auto-annotation, explorer,
+     * chunking/anno sync, filters).
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is
+     * auto-enabled unless explicitly disabled on the instance.
      */
     getAnnotationEnabledBlocks(allBlocks: Array<{
         comp: string;

package/dist/browser.js

@@ -625,11 +625,44 @@ var BlockRegistry = class {
       return value === cond.equals;
     });
   }
-  /** Check if a specific block has a specific capability. */
-  hasCapability(compType, capability) {
-    const block = this.blocks.get(compType);
-    if (!block) return false;
-    return !!block.capabilities[capability];
+  /**
+   * Check if a specific block has a specific capability.
+   *
+   * Type-level by default (keyed off `compType`). Pass the block INSTANCE as the
+   * optional third arg to honour per-instance overrides — today the only one is
+   * the annotation kill-switch: an annotation-capable block type returns `false`
+   * for the `annotation` capability when the instance sets
+   * `props.annotations.disable: true` in its tpl config. All other capabilities
+   * (and the no-instance form) fall through to the plain type-level check, so
+   * existing 2-arg callers are unaffected.
+   */
+  hasCapability(compType, capability, block) {
+    const def = this.blocks.get(compType);
+    if (!def) return false;
+    if (!def.capabilities[capability]) return false;
+    if (capability === "annotation" && block && this.isAnnotationDisabledForBlock(block)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Per-instance annotation kill-switch.
+   *
+   * A block type may be annotation-capable at the registry level (e.g.
+   * LexicalTextEditor has `capabilities.annotation === true`), but an individual
+   * block instance can be opted out of annotation entirely by setting
+   * `props.annotations.disable: true` in its tpl config. Generic and config-only:
+   * to stop annotation on any field, add that prop — no code change.
+   *
+   * The single home for this `props.annotations.disable` path (note: `annotations`
+   * plural, distinct from the legacy singular `annotation.enable`). Consumed
+   * internally by `hasCapability` and `getAnnotationEnabledBlocks`, and directly
+   * by consumers that must actively suppress annotation UI (e.g. the FE block
+   * generators forcing disableViewHighlights/disableCreateHighlights), where a
+   * type-level `false` isn't enough on its own.
+   */
+  isAnnotationDisabledForBlock(block) {
+    return block?.props?.annotations?.disable === true;
   }
   /**
    * Returns true if the block stores its value as an array (Mongo schema type is Array).
@@ -659,10 +692,19 @@ var BlockRegistry = class {
    * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
    * falls back to the legacy per-instance `props.annotation.enable` toggle.
    *
-   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   * Per-instance kill-switch: any block is excluded when its tpl config sets
+   * `props.annotations.disable: true`, regardless of type-level capability. This
+   * is the single, config-only way to turn off annotation for a specific field —
+   * and because this method is the central gate used across every repo, the
+   * switch applies everywhere (annotate UI, AI auto-annotation, explorer,
+   * chunking/anno sync, filters).
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is
+   * auto-enabled unless explicitly disabled on the instance.
    */
   getAnnotationEnabledBlocks(allBlocks) {
     return allBlocks.filter((block) => {
+      if (this.isAnnotationDisabledForBlock(block)) return false;
       const blockDef = this.blocks.get(block.comp);
       if (blockDef) return !!blockDef.capabilities.annotation;
       return block.props?.annotation?.enable === true;
@@ -2324,6 +2366,24 @@ var processAuthorAndCommonFilters = (allTpls, filterScopes, annoEnabledBlocks =
           filterType: "dateRangeType",
           valuePath: "kp_date_published"
         }
+      },
+      // "Documents" filter — narrows results to specific chosen documents of the
+      // datasets in view, matched on their own _id. Options list those datasets'
+      // documents by title (documentsType fetch, which uses the ambient contentTypes);
+      // the backend matches { _id: { $in: [ids] } } via target valuePath "_id"
+      // (getValuePathQuery ObjectId-casts any `_id`-ending path).
+      {
+        filterId: "documentsFilter",
+        blockId: "documentsFilter",
+        display: "Documents",
+        value: "documents",
+        filterKey: generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: "_id",
+          scope: "doc"
+        }),
+        source: { filterType: "documentsType", scope: "tags" },
+        target: { filterType: "valuePathType", valuePath: "_id" }
       }
     ]
   }] : [];
@@ -2684,12 +2744,19 @@ var _self_managed_buildDocHierarchyConfig = ({
       const t = allTpls.find((tp) => tp.kp_content_type === ct);
       if (t?.general?.content?.title) rollupDisplayMap[ct] = t.general.content.title;
     }
+    const childByParentId = {};
+    for (const r of rollupsWithParents) {
+      if (r.parentFilterId && r.isTagRollup && r.source?.filterType === "tagType") {
+        childByParentId[r.parentFilterId] = r;
+      }
+    }
     return {
       contentType: tpl.kp_content_type,
       display: tplData?.general?.content?.title || tpl.kp_content_type,
       filters: filtersWithParents,
       rollups: rollupsWithParents,
-      rollupDisplayMap
+      rollupDisplayMap,
+      childByParentId
     };
   });
   const filteredPerDataset = perDataset.filter(

package/dist/browser.mjs

@@ -553,11 +553,44 @@ var BlockRegistry = class {
       return value === cond.equals;
     });
   }
-  /** Check if a specific block has a specific capability. */
-  hasCapability(compType, capability) {
-    const block = this.blocks.get(compType);
-    if (!block) return false;
-    return !!block.capabilities[capability];
+  /**
+   * Check if a specific block has a specific capability.
+   *
+   * Type-level by default (keyed off `compType`). Pass the block INSTANCE as the
+   * optional third arg to honour per-instance overrides — today the only one is
+   * the annotation kill-switch: an annotation-capable block type returns `false`
+   * for the `annotation` capability when the instance sets
+   * `props.annotations.disable: true` in its tpl config. All other capabilities
+   * (and the no-instance form) fall through to the plain type-level check, so
+   * existing 2-arg callers are unaffected.
+   */
+  hasCapability(compType, capability, block) {
+    const def = this.blocks.get(compType);
+    if (!def) return false;
+    if (!def.capabilities[capability]) return false;
+    if (capability === "annotation" && block && this.isAnnotationDisabledForBlock(block)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Per-instance annotation kill-switch.
+   *
+   * A block type may be annotation-capable at the registry level (e.g.
+   * LexicalTextEditor has `capabilities.annotation === true`), but an individual
+   * block instance can be opted out of annotation entirely by setting
+   * `props.annotations.disable: true` in its tpl config. Generic and config-only:
+   * to stop annotation on any field, add that prop — no code change.
+   *
+   * The single home for this `props.annotations.disable` path (note: `annotations`
+   * plural, distinct from the legacy singular `annotation.enable`). Consumed
+   * internally by `hasCapability` and `getAnnotationEnabledBlocks`, and directly
+   * by consumers that must actively suppress annotation UI (e.g. the FE block
+   * generators forcing disableViewHighlights/disableCreateHighlights), where a
+   * type-level `false` isn't enough on its own.
+   */
+  isAnnotationDisabledForBlock(block) {
+    return block?.props?.annotations?.disable === true;
   }
   /**
    * Returns true if the block stores its value as an array (Mongo schema type is Array).
@@ -587,10 +620,19 @@ var BlockRegistry = class {
    * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
    * falls back to the legacy per-instance `props.annotation.enable` toggle.
    *
-   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   * Per-instance kill-switch: any block is excluded when its tpl config sets
+   * `props.annotations.disable: true`, regardless of type-level capability. This
+   * is the single, config-only way to turn off annotation for a specific field —
+   * and because this method is the central gate used across every repo, the
+   * switch applies everywhere (annotate UI, AI auto-annotation, explorer,
+   * chunking/anno sync, filters).
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is
+   * auto-enabled unless explicitly disabled on the instance.
    */
   getAnnotationEnabledBlocks(allBlocks) {
     return allBlocks.filter((block) => {
+      if (this.isAnnotationDisabledForBlock(block)) return false;
       const blockDef = this.blocks.get(block.comp);
       if (blockDef) return !!blockDef.capabilities.annotation;
       return block.props?.annotation?.enable === true;
@@ -2252,6 +2294,24 @@ var processAuthorAndCommonFilters = (allTpls, filterScopes, annoEnabledBlocks =
           filterType: "dateRangeType",
           valuePath: "kp_date_published"
         }
+      },
+      // "Documents" filter — narrows results to specific chosen documents of the
+      // datasets in view, matched on their own _id. Options list those datasets'
+      // documents by title (documentsType fetch, which uses the ambient contentTypes);
+      // the backend matches { _id: { $in: [ids] } } via target valuePath "_id"
+      // (getValuePathQuery ObjectId-casts any `_id`-ending path).
+      {
+        filterId: "documentsFilter",
+        blockId: "documentsFilter",
+        display: "Documents",
+        value: "documents",
+        filterKey: generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: "_id",
+          scope: "doc"
+        }),
+        source: { filterType: "documentsType", scope: "tags" },
+        target: { filterType: "valuePathType", valuePath: "_id" }
       }
     ]
   }] : [];
@@ -2612,12 +2672,19 @@ var _self_managed_buildDocHierarchyConfig = ({
       const t = allTpls.find((tp) => tp.kp_content_type === ct);
       if (t?.general?.content?.title) rollupDisplayMap[ct] = t.general.content.title;
     }
+    const childByParentId = {};
+    for (const r of rollupsWithParents) {
+      if (r.parentFilterId && r.isTagRollup && r.source?.filterType === "tagType") {
+        childByParentId[r.parentFilterId] = r;
+      }
+    }
     return {
       contentType: tpl.kp_content_type,
       display: tplData?.general?.content?.title || tpl.kp_content_type,
       filters: filtersWithParents,
       rollups: rollupsWithParents,
-      rollupDisplayMap
+      rollupDisplayMap,
+      childByParentId
     };
   });
   const filteredPerDataset = perDataset.filter(

package/dist/node.d.mts

@@ -1342,6 +1342,21 @@ declare const processAuthorAndCommonFilters: (allTpls: any[], filterScopes: stri
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     }[];
 };
@@ -1471,6 +1486,7 @@ declare const _self_managed_buildDocHierarchyConfig: ({ combinedDocumentBlocks,
             filters: any[];
             rollups: any[];
             rollupDisplayMap: Record<string, string>;
+            childByParentId: Record<string, any>;
         }[];
     };
     target: {
@@ -1631,6 +1647,7 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                     filters: any[];
                     rollups: any[];
                     rollupDisplayMap: Record<string, string>;
+                    childByParentId: Record<string, any>;
                 }[];
             };
             target: {
@@ -1697,6 +1714,21 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                 filterType: string;
                 valuePath: string;
             };
+        } | {
+            filterId: string;
+            blockId: string;
+            display: string;
+            value: string;
+            filterKey: string | undefined;
+            source: {
+                filterType: string;
+                scope: string;
+                profileTypes?: undefined;
+            };
+            target: {
+                filterType: string;
+                valuePath: string;
+            };
         })[];
     })[];
 } | null)[];
@@ -1981,8 +2013,39 @@ declare class BlockRegistry {
         comp: string;
         props?: any;
     }): boolean;
-    /** Check if a specific block has a specific capability. */
-    hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * Check if a specific block has a specific capability.
+     *
+     * Type-level by default (keyed off `compType`). Pass the block INSTANCE as the
+     * optional third arg to honour per-instance overrides — today the only one is
+     * the annotation kill-switch: an annotation-capable block type returns `false`
+     * for the `annotation` capability when the instance sets
+     * `props.annotations.disable: true` in its tpl config. All other capabilities
+     * (and the no-instance form) fall through to the plain type-level check, so
+     * existing 2-arg callers are unaffected.
+     */
+    hasCapability(compType: string, capability: keyof BlockCapabilities, block?: {
+        props?: any;
+    }): boolean;
+    /**
+     * Per-instance annotation kill-switch.
+     *
+     * A block type may be annotation-capable at the registry level (e.g.
+     * LexicalTextEditor has `capabilities.annotation === true`), but an individual
+     * block instance can be opted out of annotation entirely by setting
+     * `props.annotations.disable: true` in its tpl config. Generic and config-only:
+     * to stop annotation on any field, add that prop — no code change.
+     *
+     * The single home for this `props.annotations.disable` path (note: `annotations`
+     * plural, distinct from the legacy singular `annotation.enable`). Consumed
+     * internally by `hasCapability` and `getAnnotationEnabledBlocks`, and directly
+     * by consumers that must actively suppress annotation UI (e.g. the FE block
+     * generators forcing disableViewHighlights/disableCreateHighlights), where a
+     * type-level `false` isn't enough on its own.
+     */
+    isAnnotationDisabledForBlock(block: {
+        props?: any;
+    }): boolean;
     /**
      * Returns true if the block stores its value as an array (Mongo schema type is Array).
      * Useful for callers that need to know whether to query `valuePath.0` for existence
@@ -2004,7 +2067,15 @@ declare class BlockRegistry {
      * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
      * falls back to the legacy per-instance `props.annotation.enable` toggle.
      *
-     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     * Per-instance kill-switch: any block is excluded when its tpl config sets
+     * `props.annotations.disable: true`, regardless of type-level capability. This
+     * is the single, config-only way to turn off annotation for a specific field —
+     * and because this method is the central gate used across every repo, the
+     * switch applies everywhere (annotate UI, AI auto-annotation, explorer,
+     * chunking/anno sync, filters).
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is
+     * auto-enabled unless explicitly disabled on the instance.
      */
     getAnnotationEnabledBlocks(allBlocks: Array<{
         comp: string;