@shwfed/nuxt 0.7.8 → 0.7.9

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

@@ -0,0 +1 @@
+export {serialize, ASTNode} from './index'

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

@@ -0,0 +1,259 @@
+import {UnsignedInt} from './functions.js'
+import {Optional} from './optional.js'
+
+/**
+ * Serialize a primitive value to CEL syntax
+ * @param {*} value - The value to serialize
+ * @returns {string} The CEL representation
+ */
+function serializeValue(value) {
+  if (value === null) return 'null'
+  if (typeof value === 'boolean') return String(value)
+  if (typeof value === 'bigint') return String(value)
+  if (typeof value === 'string') return serializeString(value)
+  if (value instanceof Uint8Array) return serializeBytes(value)
+  if (value instanceof UnsignedInt) return `${value.value}u`
+  if (value instanceof Optional) {
+    if (value.hasValue()) return `optional.of(${serializeValue(value.value())})`
+    return 'optional.none()'
+  }
+
+  if (typeof value === 'number') {
+    return value % 1 === 0
+      ? `${value}.0`
+      : value.toLocaleString('en-US', {useGrouping: false, maximumFractionDigits: 9})
+  }
+
+  // Handle Uint8Array deserialized from JSON (becomes plain object with numeric keys)
+  if (typeof value === 'object') {
+    const keys = Object.keys(value)
+    if (keys.every((k) => /^\d+$/.test(k))) {
+      const bytes = new Uint8Array(keys.length)
+      for (let i = 0; i < keys.length; i++) bytes[i] = value[i]
+      return serializeBytes(bytes)
+    }
+  }
+
+  return String(value)
+}
+
+/**
+ * Convert an AST back to CEL expression string
+ * @param {import("./index.js").ASTNode} ast - The AST node to convert
+ * @returns {string} The CEL expression string
+ */
+export function serialize(ast) {
+  const {op, args} = ast
+  switch (op) {
+    case 'value':
+      return serializeValue(args)
+    case 'id':
+      return args
+
+    case '||':
+    case '&&':
+    case '==':
+    case '!=':
+    case '<':
+    case '<=':
+    case '>':
+    case '>=':
+    case 'in':
+    case '+':
+    case '-':
+    case '*':
+    case '/':
+    case '%':
+      return `${wrap(args[0], op)} ${op} ${wrap(args[1], op)}`
+
+    case '!_':
+      return `!${wrap(args, op)}`
+    case '-_':
+      // Add parentheses when operand is a binary operation
+      return ['+', '-', '*', '/', '%'].includes(args.op)
+        ? `-(${serialize(args)})`
+        : `-${serialize(args)}`
+
+    case '.':
+      return `${wrap(args[0], op)}.${args[1]}`
+    case '.?':
+      return `${wrap(args[0], op)}.?${args[1]}`
+    case '[]':
+      return `${wrap(args[0], op)}[${serialize(args[1])}]`
+    case '[?]':
+      return `${wrap(args[0], op)}[?${serialize(args[1])}]`
+
+    case 'call':
+      return `${args[0]}(${args[1].map(serialize).join(', ')})`
+    case 'rcall':
+      return `${wrap(args[1], op)}.${args[0]}(${args[2].map(serialize).join(', ')})`
+
+    case 'list':
+      return `[${args.map(serialize).join(', ')}]`
+    case 'map':
+      return `{${args.map(([k, v]) => `${serialize(k)}: ${serialize(v)}`).join(', ')}}`
+
+    case '?:':
+      return `${wrap(args[0], op)} ? ${wrap(args[1], op)} : ${serialize(args[2])}`
+
+    default:
+      throw new Error(`Unknown AST operation: ${op}`)
+  }
+}
+
+/**
+ * Serialize a string value with proper escaping
+ * @param {string} str - The string to serialize
+ * @returns {string} The escaped string with quotes
+ */
+function serializeString(str) {
+  const escaped = str
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t')
+    .replace(/\f/g, '\\f')
+    .replace(/[\b]/g, '\\b')
+    .replace(/\v/g, '\\v')
+
+  let result = ''
+  for (let i = 0; i < escaped.length; i++) {
+    const code = escaped.charCodeAt(i)
+    if (code < 32 || code > 126) {
+      result +=
+        code <= 0xffff
+          ? `\\u${code.toString(16).padStart(4, '0')}`
+          : `\\U${code.toString(16).padStart(8, '0')}`
+    } else {
+      result += escaped[i]
+    }
+  }
+
+  return `"${result}"`
+}
+
+/**
+ * Serialize a bytes value
+ * @param {Uint8Array} bytes - The bytes to serialize
+ * @returns {string} The bytes literal
+ */
+function serializeBytes(bytes) {
+  let result = 'b"'
+  for (const byte of bytes) {
+    if (byte === 0x5c) result += '\\\\'
+    else if (byte === 0x22) result += '\\"'
+    else if (byte === 0x0a) result += '\\n'
+    else if (byte === 0x0d) result += '\\r'
+    else if (byte === 0x09) result += '\\t'
+    else if (byte >= 32 && byte <= 126) result += String.fromCharCode(byte)
+    else result += `\\x${byte.toString(16).padStart(2, '0')}`
+  }
+  return `${result}"`
+}
+
+/**
+ * Operator precedence (higher = tighter binding)
+ */
+const PRECEDENCE = {
+  '?:': 1,
+  '||': 2,
+  '&&': 3,
+  '==': 4,
+  '!=': 4,
+  '<': 5,
+  '<=': 5,
+  '>': 5,
+  '>=': 5,
+  in: 5,
+  '+': 6,
+  '-': 6,
+  '-_': 6,
+  '*': 7,
+  '/': 7,
+  '%': 7,
+  '!_': 8,
+  '.': 9,
+  '.?': 9,
+  '[]': 9,
+  '[?]': 9,
+  call: 9,
+  rcall: 9
+}
+
+/**
+ * Check if parentheses are needed based on operator precedence
+ * @param {ASTNode} ast - The AST node to check
+ * @param {string} parentOp - The parent operator
+ * @returns {boolean} True if parentheses are needed
+ */
+function needsParentheses(ast, parentOp) {
+  const childOp = ast.op
+  const parentPrec = PRECEDENCE[parentOp] || 0
+  const childPrec = PRECEDENCE[childOp] || 0
+
+  // Atomic operations never need parentheses
+  if (
+    childOp === 'value' ||
+    childOp === 'id' ||
+    childOp === 'call' ||
+    childOp === 'rcall' ||
+    childOp === 'list' ||
+    childOp === 'map'
+  ) {
+    return false
+  }
+
+  // Unary minus in multiplicative context: -x * y, -x * y * -z
+  if ((parentOp === '*' || parentOp === '/' || parentOp === '%') && childOp === '-_') return false
+  if (parentOp === '*' && childOp === '*' && ast.args[0].op === '-_') return false
+
+  // Member/index access chaining: a.b.c, a[0][1], a.?b.c
+  if (
+    (childOp === '.' || childOp === '[]' || childOp === '.?' || childOp === '[?]') &&
+    (parentOp === '.' ||
+      parentOp === '[]' ||
+      parentOp === '.?' ||
+      parentOp === '[?]' ||
+      parentOp === 'rcall')
+  )
+    return false
+
+  // Ternary: only wrap if child is also ternary
+  if (parentOp === '?:') return childOp === '?:'
+
+  // Unary operators: wrap if child has lower precedence
+  if (parentOp === '!_' || parentOp === '-_') return childPrec < parentPrec
+
+  // Division needs special handling
+  if (parentOp === '/' && (childOp === '*' || childOp === '+' || childOp === '-')) return true
+  if (childOp === '/' && parentOp !== undefined) return true
+  if ((parentOp === '*' || parentOp === '/') && ['+', '-', '*', '/'].includes(childOp)) {
+    return true
+  }
+
+  // Lower precedence needs parentheses
+  if (childPrec < parentPrec) return true
+
+  // Same precedence: non-associative operators need parentheses
+  if (
+    childPrec === parentPrec &&
+    (parentOp === '/' || parentOp === '%') &&
+    (childOp === '/' || childOp === '%')
+  )
+    return true
+
+  return false
+}
+
+/**
+ * Wrap expression in parentheses if needed
+ * @param {*} ast - The AST node
+ * @param {string} parentOp - The parent operator
+ * @returns {string} The serialized expression, possibly wrapped in parentheses
+ */
+function wrap(ast, parentOp) {
+  return needsParentheses(ast, parentOp) ? `(${serialize(ast)})` : serialize(ast)
+}
+
+export default serialize

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

@@ -0,0 +1,26 @@
+/**
+ * TypeChecker performs static type analysis on CEL expressions
+ * without executing them. It validates:
+ * - Variable existence and types
+ * - Function signatures and overloads
+ * - Operator compatibility using the actual overload registry
+ * - Property and index access validity
+ */
+export class TypeChecker extends Base {
+    constructor(opts: any, isEvaluating: any);
+    isEvaluating: any;
+    Error: typeof EvaluationError | typeof TypeError;
+    /**
+     * Check an expression and return its inferred type
+     * @param {Array|any} ast - The AST node to check
+     * @returns {Object} The inferred type declaration
+     * @throws {TypeError} If type checking fails
+     */
+    check(ast: any[] | any, ctx: any): Object;
+    checkAccessOnType(ast: any, ctx: any, leftType: any, allowMissingField?: boolean): any;
+    formatType(type: any): any;
+    formatTypeList(types: any): any;
+}
+import { Base } from './operators.js.js';
+import { EvaluationError } from './errors.js.js';
+import { TypeError } from './errors.js.js';

package/dist/runtime/vendor/cel-js/lib/type-checker.js

@@ -0,0 +1,81 @@
+import {TypeError, EvaluationError} from './errors.js'
+import {Base} from './operators.js'
+const toDynTypeBinding = new Map().set('A', 'dyn').set('T', 'dyn').set('K', 'dyn').set('V', 'dyn')
+
+/**
+ * TypeChecker performs static type analysis on CEL expressions
+ * without executing them. It validates:
+ * - Variable existence and types
+ * - Function signatures and overloads
+ * - Operator compatibility using the actual overload registry
+ * - Property and index access validity
+ */
+export class TypeChecker extends Base {
+  constructor(opts, isEvaluating) {
+    super(opts)
+    this.isEvaluating = isEvaluating
+    this.Error = isEvaluating ? EvaluationError : TypeError
+  }
+
+  /**
+   * Check an expression and return its inferred type
+   * @param {Array|any} ast - The AST node to check
+   * @returns {Object} The inferred type declaration
+   * @throws {TypeError} If type checking fails
+   */
+  check(ast, ctx) {
+    return (ast.checkedType ??= ast.check(this, ast, ctx))
+  }
+
+  checkAccessOnType(ast, ctx, leftType, allowMissingField = false) {
+    if (leftType === this.dynType) return leftType
+
+    const indexTypeName = (
+      ast.op === '[]' || ast.op === '[?]' ? this.check(ast.args[1], ctx) : this.stringType
+    ).type
+
+    if (leftType.kind === 'list') {
+      if (indexTypeName === 'int' || indexTypeName === 'dyn') return leftType.valueType
+      throw new this.Error(`List index must be int, got '${indexTypeName}'`, ast)
+    }
+
+    if (leftType.kind === 'map') return leftType.valueType
+
+    const customType = this.objectTypes.get(leftType.name)
+    if (customType) {
+      if (!(indexTypeName === 'string' || indexTypeName === 'dyn')) {
+        throw new this.Error(
+          `Cannot index type '${leftType.name}' with type '${indexTypeName}'`,
+          ast
+        )
+      }
+
+      if (customType.fields) {
+        let keyName
+        if (ast.op === '.' || ast.op === '.?') keyName = ast.args[1]
+        else if (ast.args[1].op === 'value') keyName = ast.args[1].args
+
+        if (typeof keyName === 'string') {
+          const fieldType = customType.fields[keyName]
+          if (fieldType) return fieldType
+          // For optional access, missing field returns dyn; for regular access, throw
+          if (allowMissingField) return this.dynType
+          throw new this.Error(`No such key: ${keyName}`, ast)
+        }
+      }
+      return this.dynType
+    }
+
+    // No other types support indexing/property access
+    throw new this.Error(`Cannot index type '${this.formatType(leftType)}'`, ast)
+  }
+
+  formatType(type) {
+    if (!type.hasPlaceholderType) return type.name
+    return type.templated(this.registry, toDynTypeBinding).name
+  }
+
+  formatTypeList(types) {
+    return types.map((t) => this.formatType(t)).join(', ')
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/nuxt",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -27,10 +27,10 @@
     "dev": "npm run dev:prepare && nuxt dev playground",
     "dev:build": "nuxt build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "prepare": "simple-git-hooks",
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release --push && npm publish",
     "release:major": "npm run lint && npm run test && npm run prepack && changelogen --major --release --push && npm publish",
     "lint": "eslint .",
-    "postinstall": "husky",
     "test": "vitest run",
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
@@ -42,7 +42,6 @@
     "@fontsource-variable/noto-sans-sc": "^5.2.10",
     "@iconify/vue": "^5.0.0",
     "@intlify/unplugin-vue-i18n": "^11.0.3",
-    "@marcbachmann/cel-js": "^7.2.1",
     "@nuxt/fonts": "^0.14.0",
     "@nuxt/kit": "^4.3.0",
     "@tailwindcss/typography": "^0.5.19",
@@ -83,9 +82,9 @@
     "@vueuse/nuxt": "^14.2.1",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
-    "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "nuxt": "^4.3.0",
+    "simple-git-hooks": "^2.13.1",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
     "vue-tsc": "^3.2.4"
@@ -95,6 +94,10 @@
       "@commitlint/config-conventional"
     ]
   },
+  "simple-git-hooks": {
+    "pre-commit": "bunx lint-staged",
+    "commit-msg": "bunx commitlint --edit \"$1\""
+  },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,vue}": [
       "eslint --fix"

package/dist/runtime/components/locale.d.vue.ts

@@ -1,14 +0,0 @@
-interface LocaleItem {
-    locale: string;
-    message: string;
-}
-type __VLS_ModelProps = {
-    modelValue?: Array<LocaleItem>;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: LocaleItem[] | undefined) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: LocaleItem[] | undefined) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/locale.vue

@@ -1,89 +0,0 @@
-<script setup>
-import { Icon } from "@iconify/vue";
-import { useSortable } from "@vueuse/integrations/useSortable";
-import { useTemplateRef } from "vue";
-import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText } from "./ui/input-group";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger
-} from "./ui/dropdown-menu";
-const list = defineModel({ type: Array });
-const ul = useTemplateRef("ul");
-useSortable(ul, list);
-const allLocales = ["zh", "ja", "en"];
-const localeNames = {
-  zh: "\u4E2D\u6587",
-  ja: "\u65E5\u672C\u8A9E",
-  en: "English"
-};
-const getAvailableLocales = (currentItem) => {
-  const selectedLocales = new Set(list.value?.map((i) => i.locale) ?? []);
-  return allLocales.filter((locale) => !selectedLocales.has(locale) || locale === currentItem.locale);
-};
-const removeItem = (item) => {
-  if (list.value === void 0) {
-    return;
-  }
-  const index = list.value.indexOf(item);
-  if (index > -1) {
-    list.value.splice(index, 1);
-  }
-};
-</script>
-
-<template>
-  <div
-    ref="ul"
-    class="flex flex-col gap-2"
-  >
-    <InputGroup
-      v-for="item in list"
-      :key="item.locale"
-      class="bg-white/90"
-    >
-      <InputGroupAddon
-        align="inline-start"
-        data-drag-handle
-      >
-        <Icon icon="fluent:re-order-dots-vertical-20-regular" />
-      </InputGroupAddon>
-      <InputGroupAddon align="inline-start">
-        <DropdownMenu>
-          <DropdownMenuTrigger as-child>
-            <InputGroupAddon
-              align="inline-start"
-              class="cursor-pointer"
-            >
-              <Icon :icon="`circle-flags:lang-${item.locale}`" />
-            </InputGroupAddon>
-          </DropdownMenuTrigger>
-          <DropdownMenuContent>
-            <DropdownMenuItem
-              v-for="locale in getAvailableLocales(item)"
-              :key="locale"
-              @select="item.locale = locale"
-            >
-              <Icon :icon="`circle-flags:lang-${locale}`" />
-              {{ localeNames[locale] }}
-            </DropdownMenuItem>
-          </DropdownMenuContent>
-        </DropdownMenu>
-      </InputGroupAddon>
-      <InputGroupAddon align="inline-end">
-        <InputGroupButton
-          align="inline-end"
-          variant="destructive"
-          @click="removeItem(item)"
-        >
-          <Icon icon="fluent:delete-20-regular" />
-        </InputGroupButton>
-      </InputGroupAddon>
-      <InputGroupText
-        v-model="item.message"
-        class="flex-1"
-      />
-    </InputGroup>
-  </div>
-</template>

package/dist/runtime/components/locale.vue.d.ts

@@ -1,14 +0,0 @@
-interface LocaleItem {
-    locale: string;
-    message: string;
-}
-type __VLS_ModelProps = {
-    modelValue?: Array<LocaleItem>;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: LocaleItem[] | undefined) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: LocaleItem[] | undefined) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/query.d.vue.ts

@@ -1,30 +0,0 @@
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
-    identifier: string;
-} & {
-    modelValue?: Record<string, unknown>;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Record<string, unknown>) => any;
-}, string, import("vue").PublicProps, Readonly<{
-    identifier: string;
-} & {
-    modelValue?: Record<string, unknown>;
-}> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Record<string, unknown>) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    option?: (props: {
-        option: {
-            readonly label: {
-                readonly [x: string]: string;
-            };
-            readonly value: string | number;
-            readonly icon?: string | undefined;
-        };
-    }) => any;
-}>;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};