liminal 0.4.1 → 0.5.2

package/util/fixTemplateStrings.ts

@@ -0,0 +1,99 @@
+const INDENTATION_RE = /^\n([ \t]+)/
+const ESCAPE_SEQ_RE = /\\([`${\\]|\n)/g
+const LAST_INDENTATION_RE = /\n[ \t]+$/
+
+export function fixTemplateStrings(template: TemplateStringsArray): { readonly raw: readonly string[] } {
+  const firstSegment = template.raw[0]!
+  const leadingIndentMatch = INDENTATION_RE.exec(firstSegment)
+  const indentation = leadingIndentMatch?.[1]
+
+  const rawLength = template.raw.length
+  const result = 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, "")
+    }
+
+    result[i] = str
+  }
+
+  return { raw: result }
+}
+
+const LEADING_SPACE_RE = /^([ \t]*)/
+/**
+ * Applies template string indentation to substituted values with line breaks
+ *
+ * @param strings - The template strings array (processed through fixTemplateStrings)
+ * @param values - The substitution values
+ * @returns - The formatted string with properly indented substitutions
+ */
+export function applyTemplateWithIndentation(strings: TemplateStringsArray, ...values: any[]): string {
+  const fixedStrings = fixTemplateStrings(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("")
+}

package/util/isAsyncIterator.ts

@@ -0,0 +1,6 @@
+export function isAsyncIterator(value: unknown): value is AsyncIteratorObject<unknown, unknown, unknown> {
+  return typeof value === "object"
+    && value != null
+    && Symbol.asyncIterator in value
+    && typeof value[Symbol.asyncIterator] === "function"
+}

package/util/isIterator.ts

@@ -0,0 +1,6 @@
+export function isIterator(value: unknown): value is IteratorObject<unknown, unknown, unknown> {
+  return typeof value === "object"
+    && value != null
+    && Symbol.iterator in value
+    && typeof value[Symbol.iterator] === "function"
+}

package/util/isJSONValue.ts

@@ -0,0 +1,20 @@
+import type { JSONValue } from "./JSONValue.ts"
+
+export function isJSONValue(value: unknown): value is JSONValue {
+  if (value === null) {
+    return true
+  }
+
+  if (Array.isArray(value)) {
+    return value.every((item) => isJSONValue(item))
+  }
+
+  if (typeof value === "object") {
+    if (value === null) {
+      return true
+    }
+    return Object.values(value).every((v) => isJSONValue(v))
+  }
+
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+}

package/util/isPropertyKey.ts

@@ -0,0 +1,3 @@
+export function isPropertyKey(value: unknown): value is number | string | symbol {
+  return typeof value === "number" || typeof value === "string" || typeof value === "symbol"
+}

package/util/isTemplateStringsArray.ts

@@ -0,0 +1,3 @@
+export function isTemplateStringsArray(value: unknown): value is TemplateStringsArray {
+  return Array.isArray(value) && "raw" in value && Array.isArray(value.raw)
+}

package/util/jsonEquals.ts

@@ -0,0 +1,41 @@
+import type { JSONValue } from "./JSONValue"
+
+export function jsonEquals(actual: JSONValue, expected: JSONValue): boolean {
+  if (actual === expected) {
+    return true
+  }
+
+  if (typeof actual !== typeof expected) {
+    return false
+  }
+
+  if (actual === null || expected === null) {
+    return actual === expected
+  }
+
+  if (Array.isArray(actual)) {
+    if (!Array.isArray(expected)) {
+      return false
+    }
+    if (actual.length !== expected.length) {
+      return false
+    }
+    return actual.every((e, i) => jsonEquals(e, expected[i]!))
+  }
+
+  if (typeof actual === "object") {
+    if (typeof expected !== "object" || Array.isArray(expected)) {
+      return false
+    }
+    const keys = Object.keys(actual)
+    if (keys.length !== Object.keys(expected).length) {
+      return false
+    }
+    return keys.every((key) =>
+      Object.prototype.hasOwnProperty.call(expected, key)
+      && jsonEquals(actual[key]!, expected[key]!)
+    )
+  }
+
+  return actual === expected
+}

package/util/nullaryMemo.ts

@@ -0,0 +1,11 @@
+export function nullaryMemo<T>(f: () => T): () => T {
+  let initialized = false
+  let value: T | undefined = undefined
+  return () => {
+    if (!initialized) {
+      value = f()
+      initialized = true
+    }
+    return value!
+  }
+}

package/util/peekLast.ts

@@ -0,0 +1,3 @@
+export function peekLast<T>(set: Set<T>): T | undefined {
+  return [...set][set.size - 1]
+}

package/util/unimplemented.ts

@@ -0,0 +1,5 @@
+import { LiminalAssertionError } from "../LiminalAssertionError.ts"
+
+export function unimplemented(): never {
+  throw new LiminalAssertionError("Unimplemented")
+}

package/util/unreachable.ts

@@ -0,0 +1,5 @@
+import { LiminalAssertionError } from "../LiminalAssertionError.ts"
+
+export function unreachable(): never {
+  throw new LiminalAssertionError("Unreachable")
+}

package/util/unwrapDeferred.ts

@@ -0,0 +1,5 @@
+import type { DeferredOr } from "./DeferredOr.ts"
+
+export function unwrapDeferred<T>(deferred: DeferredOr<T>): T {
+  return typeof deferred === "function" ? (deferred as () => T)() : deferred
+}

package/util/util.ts

@@ -0,0 +1,10 @@
+export * from "./assert.ts"
+export * from "./dedent.ts"
+export * from "./DeferredOr.ts"
+export * from "./isAsyncIterator.ts"
+export * from "./isIterator.ts"
+export * from "./JSONKey.ts"
+export * from "./JSONSchemaMemo.ts"
+export * from "./JSONValue.ts"
+export * from "./unimplemented.ts"
+export * from "./unwrapDeferred.ts"

package/lib/index.js

@@ -1 +0,0 @@
-console.log("Hello world!");