@shwfed/nuxt 0.7.8 → 0.7.9

package/dist/runtime/vendor/cel-js/lib/errors.js

@@ -0,0 +1,97 @@
+export class ParseError extends Error {
+  #node
+  constructor(message, node, cause) {
+    super(message, {cause})
+    this.name = 'ParseError'
+    this.#node = node
+
+    if (!node?.input) return
+    this.message = formatErrorWithHighlight(this.message, node)
+  }
+
+  get node() {
+    return this.#node
+  }
+
+  withAst(node) {
+    if (this.#node || !node?.input) return this
+    this.#node = node
+    this.message = formatErrorWithHighlight(this.message, node)
+    return this
+  }
+}
+
+export class EvaluationError extends Error {
+  #node
+  constructor(message, node, cause) {
+    super(message, {cause})
+    this.name = 'EvaluationError'
+    this.#node = node
+
+    if (!node?.input) return
+    this.message = formatErrorWithHighlight(this.message, node)
+  }
+
+  get node() {
+    return this.#node
+  }
+
+  withAst(node) {
+    if (this.#node || !node?.input) return this
+    this.#node = node
+    this.message = formatErrorWithHighlight(this.message, node)
+    return this
+  }
+}
+
+export class TypeError extends Error {
+  #node
+  constructor(message, node, cause) {
+    super(message, {cause})
+    this.name = 'TypeError'
+    this.#node = node
+
+    if (!node?.input) return
+    this.message = formatErrorWithHighlight(this.message, node)
+  }
+
+  get node() {
+    return this.#node
+  }
+
+  withAst(node) {
+    if (this.#node || !node?.input) return this
+    this.#node = node
+    this.message = formatErrorWithHighlight(this.message, node)
+    return this
+  }
+}
+
+function formatErrorWithHighlight(message, node) {
+  if (node?.pos === undefined) return message
+  const pos = node.pos
+  const input = node.input
+
+  let lineNum = 1
+  let currentPos = 0
+  let columnNum = 0
+  while (currentPos < pos) {
+    if (input[currentPos] === '\n') {
+      lineNum++
+      columnNum = 0
+    } else {
+      columnNum++
+    }
+    currentPos++
+  }
+
+  // Show a few lines of context
+  let contextStart = pos
+  let contextEnd = pos
+  while (contextStart > 0 && input[contextStart - 1] !== '\n') contextStart--
+  while (contextEnd < input.length && input[contextEnd] !== '\n') contextEnd++
+
+  const line = input.slice(contextStart, contextEnd)
+  const highlight = `> ${`${lineNum}`.padStart(4, ' ')} | ${line}\n${' '.repeat(9 + columnNum)}^`
+  return `${message}\n\n${highlight}`
+}

package/dist/runtime/vendor/cel-js/lib/evaluator.d.ts

@@ -0,0 +1,4 @@
+export * from './index.js'
+
+// Re-export Duration and UnsignedInt from functions.js
+export {Duration, UnsignedInt} from './functions.js'

package/dist/runtime/vendor/cel-js/lib/evaluator.js

@@ -0,0 +1,192 @@
+import {createRegistry, RootContext} from './registry.js'
+import {EvaluationError} from './errors.js'
+import {registerFunctions, Duration, UnsignedInt} from './functions.js'
+import {registerMacros} from './macros.js'
+import {registerOverloads} from './overloads.js'
+import {TypeChecker} from './type-checker.js'
+import {Parser} from './parser.js'
+import {createOptions} from './options.js'
+import {Base} from './operators.js'
+
+const globalRegistry = createRegistry({enableOptionalTypes: false})
+registerFunctions(globalRegistry)
+registerOverloads(globalRegistry)
+registerMacros(globalRegistry)
+
+class Environment {
+  #registry
+  #evaluator
+  #typeChecker
+  #evalTypeChecker
+  #parser
+
+  constructor(opts, inherited) {
+    this.opts = createOptions(opts, inherited?.opts)
+    this.#registry = (
+      inherited instanceof Environment ? inherited.#registry : globalRegistry
+    ).clone(this.opts)
+
+    const childOpts = {registry: this.#registry, opts: this.opts}
+    this.#typeChecker = new TypeChecker(childOpts)
+    this.#evalTypeChecker = new TypeChecker(childOpts, true)
+    this.#evaluator = new Evaluator(childOpts)
+    this.#parser = new Parser(this.opts.limits, this.#registry)
+    Object.freeze(this)
+  }
+
+  clone(opts) {
+    return new Environment(opts, this)
+  }
+
+  registerFunction(signature, handler, opts) {
+    this.#registry.registerFunctionOverload(signature, handler, opts)
+    return this
+  }
+
+  registerOperator(string, handler, opts) {
+    this.#registry.registerOperatorOverload(string, handler, opts)
+    return this
+  }
+
+  registerType(typename, constructor) {
+    this.#registry.registerType(typename, constructor)
+    return this
+  }
+
+  registerVariable(name, type, opts) {
+    this.#registry.registerVariable(name, type, opts)
+    return this
+  }
+
+  registerConstant(name, type, value) {
+    this.#registry.registerConstant(name, type, value)
+    return this
+  }
+
+  hasVariable(name) {
+    return this.#registry.variables.has(name)
+  }
+
+  getDefinitions() {
+    return this.#registry.getDefinitions()
+  }
+
+  check(expression) {
+    try {
+      return this.#checkAST(this.#parser.parse(expression))
+    } catch (e) {
+      return {valid: false, error: e}
+    }
+  }
+
+  #checkAST(ast) {
+    try {
+      const typeDecl = this.#typeChecker.check(ast, new RootContext(this.#registry))
+      return {valid: true, type: this.#formatTypeForCheck(typeDecl)}
+    } catch (e) {
+      return {valid: false, error: e}
+    }
+  }
+
+  #formatTypeForCheck(typeDecl) {
+    if (typeDecl.name === `list<dyn>`) return 'list'
+    if (typeDecl.name === `map<dyn, dyn>`) return 'map'
+    return typeDecl.name
+  }
+
+  parse(expression) {
+    const ast = this.#parser.parse(expression)
+    const evaluateParsed = this.#evaluateAST.bind(this, ast)
+    evaluateParsed.check = this.#checkAST.bind(this, ast)
+    evaluateParsed.ast = ast
+    return evaluateParsed
+  }
+
+  evaluate(expression, context) {
+    return this.#evaluateAST(this.#parser.parse(expression), context)
+  }
+
+  #evaluateAST(ast, ctx) {
+    ctx = new RootContext(this.#registry, ctx)
+    if (!ast.checkedType) this.#evalTypeChecker.check(ast, ctx)
+    return this.#evaluator.eval(ast, ctx)
+  }
+}
+
+class Evaluator extends Base {
+  constructor(opts) {
+    super(opts)
+    this.Error = EvaluationError
+  }
+
+  #firstMapElement(coll) {
+    if (coll instanceof Map) return coll.entries().next().value
+    for (const key in coll) return [key, coll[key]]
+  }
+
+  debugRuntimeType(value, checkedType) {
+    return checkedType?.hasDynType === false ? checkedType : this.debugTypeDeep(value)
+  }
+
+  debugTypeDeep(value) {
+    const runtimeType = this.debugType(value)
+    switch (runtimeType.kind) {
+      case 'list': {
+        const first = value instanceof Array ? value[0] : value.values().next().value
+        if (first === undefined) return runtimeType
+        return this.registry.getListType(this.debugTypeDeep(first))
+      }
+      case 'map': {
+        const first = this.#firstMapElement(value)
+        if (!first) return runtimeType
+        return this.registry.getMapType(
+          runtimeType.keyType.hasDynType ? this.debugTypeDeep(first[0]) : runtimeType.keyType,
+          runtimeType.valueType.hasDynType ? this.debugTypeDeep(first[1]) : runtimeType.valueType
+        )
+      }
+      default:
+        return runtimeType
+    }
+  }
+
+  tryEval(ast, ctx) {
+    try {
+      const res = this.eval(ast, ctx)
+      if (res instanceof Promise) return res.catch((err) => err)
+      return res
+    } catch (err) {
+      return err
+    }
+  }
+
+  eval(ast, ctx) {
+    return ast.evaluate(this, ast, ctx)
+  }
+}
+
+const globalEnvironment = new Environment({
+  unlistedVariablesAreDyn: true
+})
+
+export function parse(expression) {
+  return globalEnvironment.parse(expression)
+}
+
+export function evaluate(expression, context) {
+  return globalEnvironment.evaluate(expression, context)
+}
+
+export function check(expression) {
+  return globalEnvironment.check(expression)
+}
+
+export {Duration, UnsignedInt, Environment}
+
+export default {
+  parse,
+  evaluate,
+  check,
+  Environment,
+  Duration,
+  UnsignedInt
+}

package/dist/runtime/vendor/cel-js/lib/functions.d.ts

@@ -0,0 +1,53 @@
+import type {Registry} from './registry.js'
+
+/**
+ * Represents an unsigned integer value in CEL.
+ * Used for uint type values.
+ */
+export class UnsignedInt {
+  /**
+   * Create a new UnsignedInt.
+   * @param value - The unsigned integer value (as bigint or number)
+   * @throws Error if value is negative or exceeds uint64 max
+   */
+  constructor(value: bigint | number)
+
+  /** Get the bigint value. */
+  get value(): bigint
+
+  /** Convert to primitive bigint for operations. */
+  valueOf(): bigint
+
+  /** Convert to string representation. */
+  toString(): string
+}
+
+/**
+ * Represents a duration value in CEL.
+ * Used for google.protobuf.Duration type.
+ */
+export class Duration {
+  /**
+   * Create a new Duration.
+   * @param seconds - The number of seconds
+   * @param nanos - The number of nanoseconds (0-999999999)
+   */
+  constructor(seconds: bigint | number, nanos?: number)
+
+  /** Get the seconds component. */
+  get seconds(): bigint
+
+  /** Get the nanoseconds component. */
+  get nanos(): number
+
+  /** Convert to primitive bigint (seconds only) for operations. */
+  valueOf(): bigint
+
+  /** Convert to string representation in format like "5s", "1h30m", etc. */
+  toString(): string
+}
+
+/**
+ * Register all built-in CEL functions on the provided registry instance.
+ */
+export function registerFunctions(registry: Registry): void