@dbx-tools/shared-core 0.3.44 → 0.4.1

package/lib/src/predicate.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Fluent, callable predicate combinators that preserve TypeScript type guards.
+ *
+ * A Predicate<T, U> is:
+ * - Callable as `(value: T) => value is U`
+ * - Composable through `.and()`, `.or()`, and `.negate()`
+ *
+ * Ordinary boolean predicates are treated as narrowing to `T`, meaning they
+ * do not narrow the input type by themselves. Composed predicates passed to
+ * `.and()` / `.or()` may return any value; they are tested for truthiness.
+ *
+ * @module
+ */
+/** An ordinary boolean predicate. */
+export type PredicateFunction<T> = (value: T) => boolean;
+/** A predicate that narrows T to U. */
+export type TypePredicateFunction<T, U extends T> = (value: T) => value is U;
+/** A predicate tested for truthiness when composed with `.and()` / `.or()`. */
+export type PredicateInput<T> = (value: T) => unknown;
+/**
+ * Extracts the narrowed type from a type predicate.
+ *
+ * Ordinary boolean predicates do not narrow, so they produce T. A guard whose
+ * narrowed type is disjoint from T (`Extract<U, T>` is `never`) is treated as a
+ * non-narrowing filter and keeps T, rather than collapsing the chain to `never` -
+ * this is what a negated narrowing guard looks like (e.g. `hasName(...).negate()`,
+ * which widens back to a supertype of T).
+ */
+type NarrowedBy<T, P> = P extends (value: any) => value is infer U ? [Extract<U, T>] extends [never] ? T : Extract<U, T> : T;
+/** Intersects the narrowed types produced by a tuple of predicates. */
+type AndNarrowed<T, P extends readonly PredicateInput<T>[], Result = T> = P extends readonly [
+    infer First,
+    ...infer Rest extends readonly PredicateInput<T>[]
+] ? AndNarrowed<T, Rest, Result & NarrowedBy<T, First>> : Result;
+/** Unions the narrowed types produced by a tuple of predicates. */
+type OrNarrowed<T, P extends readonly PredicateInput<T>[], Result = never> = P extends readonly [
+    infer First,
+    ...infer Rest extends readonly PredicateInput<T>[]
+] ? OrNarrowed<T, Rest, Result | NarrowedBy<T, First>> : Result;
+/**
+ * A callable predicate with fluent composition methods.
+ *
+ * T is the accepted input type.
+ * U is the type established when the predicate returns true.
+ */
+export interface Predicate<T, U extends T = T> {
+    (value: T): value is U;
+    /**
+     * Returns a predicate requiring this predicate and every supplied predicate
+     * to match.
+     *
+     * Type guards are intersected. Additional predicates are checked against the
+     * type already established by this predicate.
+     */
+    and<const P extends readonly PredicateInput<U>[]>(...predicates: P): Predicate<T, Extract<U & AndNarrowed<U, P>, T>>;
+    /**
+     * Returns a predicate requiring this predicate or any supplied predicate
+     * to match.
+     *
+     * Type guards are unioned. Because an ordinary boolean predicate could
+     * accept any value of `U`, including one causes the resulting predicate to
+     * narrow only to `U`.
+     */
+    or<const P extends readonly PredicateInput<U>[]>(...predicates: P): Predicate<T, Extract<U | OrNarrowed<U, P>, T>>;
+    /**
+     * Returns the logical inverse of this predicate.
+     *
+     * For a type predicate narrowing T to U, the result narrows to
+     * Exclude<T, U>.
+     */
+    negate(): Predicate<T, Exclude<T, U>>;
+}
+/**
+ * Wraps a type predicate while preserving its narrowed type.
+ */
+export declare function create<T, U extends T>(predicate: TypePredicateFunction<T, U>): Predicate<T, U>;
+/**
+ * Wraps an ordinary boolean or truthy predicate.
+ */
+export declare function create<T>(predicate: PredicateInput<T>): Predicate<T, T>;
+export {};

package/lib/src/predicate.js

@@ -0,0 +1,43 @@
+/**
+ * Fluent, callable predicate combinators that preserve TypeScript type guards.
+ *
+ * A Predicate<T, U> is:
+ * - Callable as `(value: T) => value is U`
+ * - Composable through `.and()`, `.or()`, and `.negate()`
+ *
+ * Ordinary boolean predicates are treated as narrowing to `T`, meaning they
+ * do not narrow the input type by themselves. Composed predicates passed to
+ * `.and()` / `.or()` may return any value; they are tested for truthiness.
+ *
+ * @module
+ */
+/** Coerce a predicate result to boolean the way `if (...)` does. */
+function isTruthy(test) {
+    return (value) => Boolean(test(value));
+}
+/**
+ * Creates the callable predicate object.
+ *
+ * The public generic behavior is provided by Predicate<T, U>. Runtime
+ * composition coerces predicate results to boolean; type predicates are
+ * ordinary boolean functions at runtime.
+ */
+function buildPredicate(test) {
+    const check = isTruthy(test);
+    const callable = ((value) => check(value));
+    return Object.assign(callable, {
+        and(...predicates) {
+            return buildPredicate((value) => check(value) && predicates.every((predicate) => isTruthy(predicate)(value)));
+        },
+        or(...predicates) {
+            return buildPredicate((value) => check(value) || predicates.some((predicate) => isTruthy(predicate)(value)));
+        },
+        negate() {
+            return buildPredicate((value) => !check(value));
+        },
+    });
+}
+export function create(predicate) {
+    return buildPredicate(predicate);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"predicate.js","sourceRoot":"","sources":["../../src/predicate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmFH,oEAAoE;AACpE,SAAS,QAAQ,CAAI,IAA2B;IAC9C,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAiB,IAA2B;IACjE,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7B,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAQ,EAAc,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAA6B,CAAC;IAEtF,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE;QAC7B,GAAG,CACD,GAAG,UAAa;YAGhB,OAAO,cAAc,CACnB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAU,CAAC,CAAC,CAC5F,CAAC;QACJ,CAAC;QAED,EAAE,CACA,GAAG,UAAa;YAGhB,OAAO,cAAc,CACnB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAU,CAAC,CAAC,CAC3F,CAAC;QACJ,CAAC;QAED,MAAM;YACJ,OAAO,cAAc,CAAmB,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACpE,CAAC;KACF,CAAoB,CAAC;AACxB,CAAC;AAYD,MAAM,UAAU,MAAM,CACpB,SAA0D;IAE1D,OAAO,cAAc,CAAO,SAAS,CAAC,CAAC;AACzC,CAAC","sourcesContent":["/**\n * Fluent, callable predicate combinators that preserve TypeScript type guards.\n *\n * A Predicate<T, U> is:\n * - Callable as `(value: T) => value is U`\n * - Composable through `.and()`, `.or()`, and `.negate()`\n *\n * Ordinary boolean predicates are treated as narrowing to `T`, meaning they\n * do not narrow the input type by themselves. Composed predicates passed to\n * `.and()` / `.or()` may return any value; they are tested for truthiness.\n *\n * @module\n */\n\n/** An ordinary boolean predicate. */\nexport type PredicateFunction<T> = (value: T) => boolean;\n\n/** A predicate that narrows T to U. */\nexport type TypePredicateFunction<T, U extends T> = (value: T) => value is U;\n\n/** A predicate tested for truthiness when composed with `.and()` / `.or()`. */\nexport type PredicateInput<T> = (value: T) => unknown;\n\n/**\n * Extracts the narrowed type from a type predicate.\n *\n * Ordinary boolean predicates do not narrow, so they produce T. A guard whose\n * narrowed type is disjoint from T (`Extract<U, T>` is `never`) is treated as a\n * non-narrowing filter and keeps T, rather than collapsing the chain to `never` -\n * this is what a negated narrowing guard looks like (e.g. `hasName(...).negate()`,\n * which widens back to a supertype of T).\n */\ntype NarrowedBy<T, P> = P extends (value: any) => value is infer U\n  ? [Extract<U, T>] extends [never]\n    ? T\n    : Extract<U, T>\n  : T;\n\n/** Intersects the narrowed types produced by a tuple of predicates. */\ntype AndNarrowed<T, P extends readonly PredicateInput<T>[], Result = T> = P extends readonly [\n  infer First,\n  ...infer Rest extends readonly PredicateInput<T>[],\n]\n  ? AndNarrowed<T, Rest, Result & NarrowedBy<T, First>>\n  : Result;\n\n/** Unions the narrowed types produced by a tuple of predicates. */\ntype OrNarrowed<T, P extends readonly PredicateInput<T>[], Result = never> = P extends readonly [\n  infer First,\n  ...infer Rest extends readonly PredicateInput<T>[],\n]\n  ? OrNarrowed<T, Rest, Result | NarrowedBy<T, First>>\n  : Result;\n\n/**\n * A callable predicate with fluent composition methods.\n *\n * T is the accepted input type.\n * U is the type established when the predicate returns true.\n */\nexport interface Predicate<T, U extends T = T> {\n  (value: T): value is U;\n\n  /**\n   * Returns a predicate requiring this predicate and every supplied predicate\n   * to match.\n   *\n   * Type guards are intersected. Additional predicates are checked against the\n   * type already established by this predicate.\n   */\n  and<const P extends readonly PredicateInput<U>[]>(\n    ...predicates: P\n  ): Predicate<T, Extract<U & AndNarrowed<U, P>, T>>;\n\n  /**\n   * Returns a predicate requiring this predicate or any supplied predicate\n   * to match.\n   *\n   * Type guards are unioned. Because an ordinary boolean predicate could\n   * accept any value of `U`, including one causes the resulting predicate to\n   * narrow only to `U`.\n   */\n  or<const P extends readonly PredicateInput<U>[]>(\n    ...predicates: P\n  ): Predicate<T, Extract<U | OrNarrowed<U, P>, T>>;\n\n  /**\n   * Returns the logical inverse of this predicate.\n   *\n   * For a type predicate narrowing T to U, the result narrows to\n   * Exclude<T, U>.\n   */\n  negate(): Predicate<T, Exclude<T, U>>;\n}\n\n/** Coerce a predicate result to boolean the way `if (...)` does. */\nfunction isTruthy<T>(test: (value: T) => unknown): PredicateFunction<T> {\n  return (value) => Boolean(test(value));\n}\n\n/**\n * Creates the callable predicate object.\n *\n * The public generic behavior is provided by Predicate<T, U>. Runtime\n * composition coerces predicate results to boolean; type predicates are\n * ordinary boolean functions at runtime.\n */\nfunction buildPredicate<T, U extends T>(test: (value: T) => unknown): Predicate<T, U> {\n  const check = isTruthy(test);\n  const callable = ((value: T): value is U => check(value)) as (value: T) => value is U;\n\n  return Object.assign(callable, {\n    and<const P extends readonly PredicateInput<U>[]>(\n      ...predicates: P\n    ): Predicate<T, Extract<U & AndNarrowed<U, P>, T>> {\n      type Result = Extract<U & AndNarrowed<U, P>, T>;\n      return buildPredicate<T, Result>(\n        (value) => check(value) && predicates.every((predicate) => isTruthy(predicate)(value as U)),\n      );\n    },\n\n    or<const P extends readonly PredicateInput<U>[]>(\n      ...predicates: P\n    ): Predicate<T, Extract<U | OrNarrowed<U, P>, T>> {\n      type Result = Extract<U | OrNarrowed<U, P>, T>;\n      return buildPredicate<T, Result>(\n        (value) => check(value) || predicates.some((predicate) => isTruthy(predicate)(value as U)),\n      );\n    },\n\n    negate(): Predicate<T, Exclude<T, U>> {\n      return buildPredicate<T, Exclude<T, U>>((value) => !check(value));\n    },\n  }) as Predicate<T, U>;\n}\n\n/**\n * Wraps a type predicate while preserving its narrowed type.\n */\nexport function create<T, U extends T>(predicate: TypePredicateFunction<T, U>): Predicate<T, U>;\n\n/**\n * Wraps an ordinary boolean or truthy predicate.\n */\nexport function create<T>(predicate: PredicateInput<T>): Predicate<T, T>;\n\nexport function create<T, U extends T = T>(\n  predicate: TypePredicateFunction<T, U> | PredicateInput<T>,\n): Predicate<T, U> {\n  return buildPredicate<T, U>(predicate);\n}\n"]}

package/lib/src/string.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Options controlling {@link tokenizeWithOptions}. All default off except
+ * `camelCase`.
+ *
+ * - `distinct` - drop duplicate tokens (first occurrence wins).
+ * - `lowerCase` - lowercase every token.
+ * - `capitalize` - upper-case each token's first letter (then
+ *   {@link TOKENIZE_OVERRIDES} fix up `ai` -> `AI` and `v2` -> `V2`).
+ * - `omitUriScheme` - strip a leading `scheme://` before tokenizing.
+ * - `omitEmailDomain` - keep only the local part of an email.
+ * - `camelCase` - split on camelCase boundaries / digit runs / acronyms
+ *   (default `true`); when `false`, split only on non-alphanumerics.
+ */
+export type TokenizeOptions = {
+    distinct?: boolean;
+    lowerCase?: boolean;
+    capitalize?: boolean;
+    omitUriScheme?: boolean;
+    omitEmailDomain?: boolean;
+    camelCase?: boolean;
+};
+export type KeyOptions = Omit<TokenizeOptions, "lowerCase" | "capitalize"> & {
+    maxLength?: number;
+    truncateStrategy?: "hash" | "trim" | "empty";
+    truncateHashLength?: number;
+};
+export type IdentifierOptions = KeyOptions & {
+    delimiter?: string;
+};
+export declare function tokenizeWithOptions(options: TokenizeOptions, ...values: unknown[]): Generator<string>;
+export declare function tokenize(...values: unknown[]): Generator<string>;
+/**
+ * Join tokenized values with `delimiter`. When the next token would push the
+ * result over `maxLength`: `trim` stops adding; `empty` returns `""`; `hash`
+ * appends a digest of accepted tokens plus the overflow token if the result
+ * still fits, otherwise `""`.
+ */
+export declare function toIdentifierWithOptions(options: IdentifierOptions, ...values: unknown[]): string;
+export declare function toIdentifier(...values: unknown[]): string;
+/**
+ * Slugified identifier: same rules as {@link toIdentifierWithOptions} with the
+ * delimiter forced to `-`. Accepts {@link KeyOptions} so callers cannot
+ * override the delimiter.
+ */
+export declare function toSlugWithOptions(options: KeyOptions, ...values: unknown[]): string;
+export declare function toSlug(...values: unknown[]): string;
+/**
+ * Trim `value` and return `null` for non-strings, `undefined`, or
+ * strings that are empty after trimming. Lets call sites collapse the
+ * common
+ *
+ * ```ts
+ * typeof v === "string" && v.trim() ? v.trim() : null
+ * ```
+ *
+ * dance into a single helper. Useful for HTTP header / query / form
+ * extractors where downstream code wants `string | null` to drive a
+ * cheap `??` / `if (x)` cascade.
+ */
+export declare function trimToNull(value: unknown): string | null;
+/**
+ * Normalize a config list that may arrive as an array or as a single
+ * comma/whitespace-separated string: split, apply `transform`, drop empties,
+ * and de-duplicate (first occurrence wins).
+ *
+ * This is the shape every allow-list / fallback-order setting in this repo
+ * takes, because the same value can come from typed config (`string[]`) or from
+ * an environment variable (`"a, b c"`). Pass `transform` to normalize entries
+ * as they are read; it defaults to trimming.
+ *
+ * @example
+ * parseList("docs.example.com, *.databricks.com");
+ * parseList(process.env.MODEL_FALLBACKS);
+ * parseList(raw, normalizeUrlPattern);
+ */
+export declare function parseList(raw: string | readonly string[] | undefined | null, transform?: (entry: string) => string): string[];
+/**
+ * {@link trimToNull} with an empty-string miss instead of `null`, for callers
+ * that build a string unconditionally and treat "absent" as "".
+ *
+ * Reading loosely-typed JSON is the motivating case: a field that should be a
+ * string may be missing or the wrong type, and the caller wants `""` rather
+ * than a null check at every access.
+ *
+ * @example
+ * const title = trimToEmpty(record.title); // always a string
+ */
+export declare function trimToEmpty(value: unknown): string;
+/**
+ * Trim the first usable string out of `value`. Returns `null` when
+ * `value` is `undefined`, `null`, an empty string, or an array whose
+ * first string member is empty. Mirrors how Express / Node header
+ * accessors expose single vs. repeated headers - the first
+ * non-empty entry wins, everything else is ignored.
+ */
+export declare function firstNonEmpty(value: unknown): string | null;
+/**
+ * Escape the five characters significant in HTML text and
+ * double-quoted attribute values (`&`, `<`, `>`, `"`, `'`) so an
+ * untrusted string can be interpolated into markup without breaking
+ * out of its context. `&` is replaced first so ampersands introduced
+ * by the later replacements aren't double-escaped.
+ */
+export declare function escapeHtml(value: string): string;
+/**
+ * Slugify `value` (using the standard {@link toIdentifierWithOptions}
+ * tokenizer + delimiter rules) and **always** suffix a short
+ * deterministic hash. Use when you need a stable, slugified id that
+ * is guaranteed to be unique across descriptions sharing the same
+ * leading tokens (tool ids, cache keys, etc.).
+ *
+ * Behaviour differs from `toIdentifierWithOptions({ maxLength,
+ * truncateStrategy: "hash" })`: that helper only appends a hash when
+ * the slug *overflows* `maxLength`. This helper appends a hash
+ * unconditionally so the result is collision-resistant even for
+ * short inputs. The hash is computed over the raw `value` so two
+ * descriptions producing the same slug still get different ids.
+ *
+ * @param value - Source string (typically a tool/agent description).
+ * @param options.delimiter - Token separator (default `"_"`).
+ * @param options.slugMaxLength - Cap on the slug portion (the part
+ *   before the hash). Default 32.
+ * @param options.hashLength - Length of the suffix produced by
+ *   {@link fnvHashWithOptions} (Crockford-style base-32 alphabet, max 7
+ *   chars). Default 6.
+ * @param options.fallbackPrefix - Prefix used when the slug is empty
+ *   (e.g. punctuation-only input). Default `"id"`.
+ */
+export declare function toUniqueSlug(value: string, options?: {
+    delimiter?: string;
+    slugMaxLength?: number;
+    hashLength?: number;
+    fallbackPrefix?: string;
+}): string;
+/**
+ * A node in the description tree consumed by {@link toDescription}.
+ *
+ * - `string` - a text paragraph.
+ * - `Description[]` - a sequence of stacked blocks at the same level
+ *   (no list markers). Plain text adjacent to a list (either direction)
+ *   flushes together so the prose reads as a lead-in or trailing
+ *   summary. Two text paragraphs, two adjacent lists, and anything
+ *   touching a map get a blank-line break.
+ * - `{ bullets: [...] }` / `{ numbered: [...] }` - explicit list. A
+ *   list of one bare string drops its marker (`-` / `1.`); a list of
+ *   one item with nested children keeps its marker as the visual anchor
+ *   for the indented children.
+ * - any other object - headers map: each key becomes a `Header:` line
+ *   followed by a blank line and the rendered value.
+ */
+export type Description = string | readonly Description[] | {
+    readonly [key: string]: Description;
+};
+/**
+ * Format a nested description tree as a Markdown-ish string suitable
+ * for an LLM system prompt, Zod `.describe()` block, Mastra tool
+ * description, or any other long-form text destination.
+ *
+ * Every string section is dedented (common leading whitespace stripped),
+ * right-trimmed line by line, and freed of leading / trailing blank
+ * lines, so callers can write multi-line template literals indented
+ * naturally in source without leaking that indentation into the
+ * consumer-facing output. Plain-string inputs flow through unchanged
+ * apart from the same normalization pass, so a single multi-line
+ * template literal works directly:
+ *
+ * ```ts
+ * toDescription(`
+ *   Ask the Genie space "${alias}" a question.
+ *   Pass the answer through as-is.
+ * `);
+ * // Ask the Genie space "default" a question.
+ * // Pass the answer through as-is.
+ *
+ * toDescription([
+ *   `
+ *     Ask the Genie space a question.
+ *     Phrase it from the user's perspective.
+ *   `,
+ *   { bullets: [
+ *     ["Pass the answer through as-is", { numbered: ["item", "item"] }],
+ *   ]},
+ *   { Instructions: "Reply with the SQL only." },
+ * ]);
+ * // Ask the Genie space a question.
+ * // Phrase it from the user's perspective.
+ * // - Pass the answer through as-is
+ * //   1. item
+ * //   2. item
+ * //
+ * // Instructions:
+ * //
+ * // Reply with the SQL only.
+ * ```
+ *
+ * See {@link Description} for the node grammar.
+ */
+export declare function toDescription(node: Description): string;
+/**
+ * Format a count with its noun, pluralizing (naive `+s`) unless the count is 1:
+ * `pluralize(1, "barrel")` -> `"1 barrel"`, `pluralize(3, "barrel")` ->
+ * `"3 barrels"`. Collapses the `${n} noun${n === 1 ? "" : "s"}` idiom.
+ */
+export declare function pluralize(count: number, noun: string): string;
+/**
+ * Title-case a snake / kebab / camel identifier into a human-readable label:
+ * tokenize (lowercased, capitalized), then join with spaces. Falls back to
+ * the raw `value` when it yields no tokens (e.g. punctuation-only input).
+ * `bge_large_en` -> `"Bge Large En"`, `promptId` -> `"Prompt Id"`.
+ *
+ * The single source of truth for the "humanize a column / field name" idiom -
+ * reused by the chat data-grid headers and the export renderer. Extra
+ * {@link TokenizeOptions} (e.g. `camelCase: false`) merge over the defaults.
+ */
+export declare function toLabel(value: string, options?: TokenizeOptions): string;
+/**
+ * Upper-case the first character of `value`, leaving the rest untouched.
+ * `"working"` -> `"Working"`. Collapses the
+ * `s.charAt(0).toUpperCase() + s.slice(1)` idiom.
+ */
+export declare function capitalize(value: string): string;