liminal 0.16.0 → 0.17.1

package/util/NeverTool.ts

@@ -1,10 +0,0 @@
-import * as AiTool from "@effect/ai/AiTool"
-import * as Schema from "effect/Schema"
-
-export type NeverTool = AiTool.AiTool<
-  string,
-  AiTool.AnyStructSchema,
-  Schema.Schema.Any,
-  Schema.Schema.Any,
-  never
->

package/util/Sequencer.ts

@@ -1,13 +0,0 @@
-import type * as Effect from "effect/Effect"
-
-export interface Sequencer<Provides = never, Requires = never> {
-  <Arg extends Array<Effect.All.EffectAny>>(
-    ...steps: Arg
-  ): Effect.Effect<
-    Arg extends [] ? void
-      : Arg extends [...infer _0, infer L extends Effect.All.EffectAny] ? Effect.Effect.Success<L>
-      : never,
-    Effect.Effect.Error<Arg[number]>,
-    Exclude<Effect.Effect.Context<Arg[number]>, Provides> | Requires
-  >
-}

package/util/Taggable.ts

@@ -1,14 +0,0 @@
-import * as Effect from "effect/Effect"
-
-export type Taggable<A, E, R> = <L extends Array<unknown>, E1 = never, R1 = never>(
-  template?: TaggableArg0 | Effect.Effect<string | undefined, E1, R1>,
-  ...substitutions: L
-) => Effect.Effect<
-  A,
-  ([ExtractEffect<L>] extends [never] ? never : Effect.Effect.Error<ExtractEffect<L>>) | E | E1,
-  ([ExtractEffect<L>] extends [never] ? never : Effect.Effect.Context<ExtractEffect<L>>) | R | R1
->
-
-export type TaggableArg0 = TemplateStringsArray | string | undefined
-
-type ExtractEffect<T extends Array<unknown>> = Extract<T[number], Effect.All.EffectAny>

package/util/normalizeRaw.ts

@@ -1,93 +0,0 @@
-const LEADING_SPACE_RE = /^([ \t]*)/
-const INDENTATION_RE = /^\n([ \t]+)/
-const ESCAPE_SEQ_RE = /\\([`${\\]|\n)/g
-const LAST_INDENTATION_RE = /\n[ \t]+$/
-
-export const normalizeRaw = (strings: TemplateStringsArray, values: Array<unknown>): string => {
-  const fixedStrings = normalizeTemplateStrings(strings)
-  const rawArr = fixedStrings.raw
-  const valuesLength = values.length
-
-  const resultParts = new Array(Math.max(1, rawArr.length * 2 - 1))
-  let resultIndex = 0
-
-  for (let i = 0; i < rawArr.length; i++) {
-    const str = rawArr[i] || ""
-    resultParts[resultIndex++] = str
-
-    // Only process values for non-final segments.
-    if (i < valuesLength) {
-      const value = String(values[i])
-
-      // If value has line breaks, we should indent it.
-      if (value.includes("\n")) {
-        const lastNewlineIndex = str.lastIndexOf("\n")
-
-        if (lastNewlineIndex !== -1) {
-          // Extract the indentation after the last newline.
-          const textAfterLastNewline = str.substring(lastNewlineIndex + 1)
-          const leadingSpaceMatch = LEADING_SPACE_RE.exec(textAfterLastNewline)
-          const indentationToApply = leadingSpaceMatch && leadingSpaceMatch[1] ? leadingSpaceMatch[1] : ""
-
-          if (indentationToApply) {
-            // Split the value into lines once.
-            const lines = value.split("\n")
-            const linesLength = lines.length
-
-            // First line doesn't need indentation.
-            resultParts[resultIndex++] = lines[0]
-
-            // Apply indentation to subsequent lines.
-            for (let j = 1; j < linesLength; j++) {
-              resultParts[resultIndex++] = "\n" + indentationToApply + lines[j]
-            }
-            continue
-          }
-        }
-      }
-      // For simple values or when no indentation is needed.
-      resultParts[resultIndex++] = value
-    }
-  }
-
-  // Combine all parts at once
-  return resultParts.slice(0, resultIndex).join("")
-}
-
-export const normalizeTemplateStrings = (template: TemplateStringsArray): {
-  readonly raw: ReadonlyArray<string>
-} => {
-  const leadingIndentMatch = INDENTATION_RE.exec(template.raw[0]!)
-  const indentation = leadingIndentMatch?.[1]
-
-  const rawLength = template.raw.length
-  const raw = new Array(rawLength)
-
-  for (let i = 0; i < rawLength; i++) {
-    let str = template.raw[i]!
-    // Only perform common indentation replacements if needed.
-    if (indentation) {
-      // Remove leading newline and indentation in the first segment.
-      if (i === 0) {
-        str = str.slice(indentation.length + 1)
-      }
-      // Use a simple string replacement with a regular expression for better performance.
-      str = str.replaceAll(`\n${indentation}`, "\n")
-    }
-
-    // Replace common escape sequences in a single pass.
-    str = str.replace(ESCAPE_SEQ_RE, (_match, char) => {
-      // Keep the escaped newline replacement separate for clarity.
-      return char === "\n" ? "" : char
-    })
-
-    // Handle trailing spaces only for the last segment.
-    if (indentation && i === rawLength - 1) {
-      str = str.replace(LAST_INDENTATION_RE, "")
-    }
-
-    raw[i] = str
-  }
-
-  return { raw }
-}

package/util/prefix.ts

@@ -1 +0,0 @@
-export const prefix = <K extends string>(key: K) => `liminal/${key}` as const