@seljs/schema 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.1](https://github.com/abinnovision/seljs/compare/schema-v1.0.0...schema-v1.0.1) (2026-03-16)
+
+
+### Bug Fixes
+
+* export esm and cjs ([#23](https://github.com/abinnovision/seljs/issues/23)) ([23d525d](https://github.com/abinnovision/seljs/commit/23d525d9084d18a370d4c6307b983a857a865f59))
+
 ## 1.0.0 (2026-03-13)
 
 

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema } from "./types.cjs";
+export { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema } from "./types.mjs";
+export { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema };

package/dist/types.d.cts

@@ -0,0 +1,214 @@
+import { AbiFunction } from "abitype";
+
+//#region src/types.d.ts
+/**
+ * Type reference string used throughout the schema.
+ * These are CEL type names like "int", "string", "bool", or custom types defined in the schema.
+ * For parameterized types, use CEL syntax (e.g., "list<sol_address>").
+ */
+type TypeRef = string;
+/**
+ * Root schema type for SEL expression language.
+ * Contains all contracts, variables, types, functions, and macros available in a SEL environment.
+ */
+interface SELSchema {
+  /**
+   * Schema format version
+   */
+  version: string;
+  /**
+   * Available contracts and their methods
+   */
+  contracts: ContractSchema[];
+  /**
+   * Variables available in expressions (e.g., "user", "blockNumber")
+   */
+  variables: VariableSchema[];
+  /**
+   * Type definitions (primitives, structs, enums)
+   */
+  types: TypeSchema[];
+  /**
+   * Built-in CEL functions
+   */
+  functions: FunctionSchema[];
+  /**
+   * CEL macros (all, exists, map, filter, etc.)
+   */
+  macros: MacroSchema[];
+}
+/**
+ * Schema for a contract with available methods.
+ * Methods are view/pure functions that can be called in CEL expressions.
+ */
+interface ContractSchema {
+  /**
+   * Identifier used in expressions: erc20.balanceOf(...)
+   */
+  name: string;
+  /**
+   * Contract address (for display/documentation)
+   */
+  address: `0x${string}`;
+  /**
+   * Human-readable description
+   */
+  description?: string;
+  /**
+   * Available methods (view/pure functions only)
+   */
+  methods: MethodSchema[];
+}
+/**
+ * Schema for a contract method.
+ * Represents a view or pure function that can be called in CEL expressions.
+ */
+interface MethodSchema {
+  /**
+   * Method name: "balanceOf"
+   */
+  name: string;
+  /**
+   * From NatSpec @notice or custom
+   */
+  description?: string;
+  /**
+   * Method parameters
+   */
+  params: ParamSchema[];
+  /** Raw ABI function entry for viem encoding/decoding */
+  abi: AbiFunction;
+  /**
+   * Return type reference
+   */
+  returns: TypeRef;
+  /**
+   * For autocomplete grouping
+   */
+  category?: string;
+}
+/**
+ * Schema for a method parameter or type field.
+ * Used in methods, structs, and function signatures.
+ */
+interface ParamSchema {
+  /**
+   * Parameter name: "owner"
+   */
+  name: string;
+  /**
+   * Type reference: "address", "uint256", etc.
+   */
+  type: TypeRef;
+  /**
+   * From NatSpec @param or custom
+   */
+  description?: string;
+}
+/**
+ * Schema for a variable available in CEL expressions.
+ * Represents runtime context values like "user", "blockNumber", etc.
+ */
+interface VariableSchema {
+  /**
+   * Variable name available in expressions
+   */
+  name: string;
+  /**
+   * Type reference
+   */
+  type: TypeRef;
+  /**
+   * Description for hover/documentation
+   */
+  description?: string;
+  /**
+   * Example value for documentation
+   */
+  example?: string;
+}
+/**
+ * Schema for a type definition.
+ * These are reusable types that can be used in method signatures, variable types, and function signatures.
+ */
+interface TypeSchema {
+  /**
+   * Type name
+   */
+  name: string;
+  /**
+   * Type category
+   */
+  kind: "primitive" | "struct";
+  /**
+   * For structs: field definitions
+   */
+  fields?: ParamSchema[];
+  /**
+   * Description
+   */
+  description?: string;
+}
+/**
+ * Schema for a built-in CEL function.
+ *
+ * Functions are either **free functions** (`size(list)`) or
+ * **receiver methods** (`string.startsWith(prefix)`).
+ * When `receiverType` is set, the function is a method that can only be
+ * called on expressions of that type using dot-syntax.
+ */
+interface FunctionSchema {
+  /**
+   * Function name: "size", "string", "int", "startsWith"
+   */
+  name: string;
+  /**
+   * Function signature for display
+   *
+   * e.g., "size(list<T>): int" | "string.startsWith(prefix): bool"
+   */
+  signature: string;
+  /**
+   * Description
+   */
+  description?: string;
+  /**
+   * Parameter documentation (excludes the receiver for methods)
+   */
+  params: ParamSchema[];
+  /**
+   * Return type
+   */
+  returns: TypeRef;
+  /**
+   * When set, this function is a receiver method on the given type.
+   * E.g., `receiverType: "string"` means it is called as `expr.name(...)`.
+   */
+  receiverType?: TypeRef;
+}
+/**
+ * Schema for a CEL macro.
+ * Macros are syntactic sugar that expand to function calls.
+ */
+interface MacroSchema {
+  /**
+   * Macro name: "all", "exists", "map", "filter"
+   */
+  name: string;
+  /**
+   * Usage pattern
+   *
+   * e.g., "list.all(x, predicate)" | "list.map(x, transform)"
+   */
+  pattern: string;
+  /**
+   * Description
+   */
+  description?: string;
+  /**
+   * Example
+   */
+  example?: string;
+}
+//#endregion
+export { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema };

package/dist/types.d.mts

@@ -0,0 +1,214 @@
+import { AbiFunction } from "abitype";
+
+//#region src/types.d.ts
+/**
+ * Type reference string used throughout the schema.
+ * These are CEL type names like "int", "string", "bool", or custom types defined in the schema.
+ * For parameterized types, use CEL syntax (e.g., "list<sol_address>").
+ */
+type TypeRef = string;
+/**
+ * Root schema type for SEL expression language.
+ * Contains all contracts, variables, types, functions, and macros available in a SEL environment.
+ */
+interface SELSchema {
+  /**
+   * Schema format version
+   */
+  version: string;
+  /**
+   * Available contracts and their methods
+   */
+  contracts: ContractSchema[];
+  /**
+   * Variables available in expressions (e.g., "user", "blockNumber")
+   */
+  variables: VariableSchema[];
+  /**
+   * Type definitions (primitives, structs, enums)
+   */
+  types: TypeSchema[];
+  /**
+   * Built-in CEL functions
+   */
+  functions: FunctionSchema[];
+  /**
+   * CEL macros (all, exists, map, filter, etc.)
+   */
+  macros: MacroSchema[];
+}
+/**
+ * Schema for a contract with available methods.
+ * Methods are view/pure functions that can be called in CEL expressions.
+ */
+interface ContractSchema {
+  /**
+   * Identifier used in expressions: erc20.balanceOf(...)
+   */
+  name: string;
+  /**
+   * Contract address (for display/documentation)
+   */
+  address: `0x${string}`;
+  /**
+   * Human-readable description
+   */
+  description?: string;
+  /**
+   * Available methods (view/pure functions only)
+   */
+  methods: MethodSchema[];
+}
+/**
+ * Schema for a contract method.
+ * Represents a view or pure function that can be called in CEL expressions.
+ */
+interface MethodSchema {
+  /**
+   * Method name: "balanceOf"
+   */
+  name: string;
+  /**
+   * From NatSpec @notice or custom
+   */
+  description?: string;
+  /**
+   * Method parameters
+   */
+  params: ParamSchema[];
+  /** Raw ABI function entry for viem encoding/decoding */
+  abi: AbiFunction;
+  /**
+   * Return type reference
+   */
+  returns: TypeRef;
+  /**
+   * For autocomplete grouping
+   */
+  category?: string;
+}
+/**
+ * Schema for a method parameter or type field.
+ * Used in methods, structs, and function signatures.
+ */
+interface ParamSchema {
+  /**
+   * Parameter name: "owner"
+   */
+  name: string;
+  /**
+   * Type reference: "address", "uint256", etc.
+   */
+  type: TypeRef;
+  /**
+   * From NatSpec @param or custom
+   */
+  description?: string;
+}
+/**
+ * Schema for a variable available in CEL expressions.
+ * Represents runtime context values like "user", "blockNumber", etc.
+ */
+interface VariableSchema {
+  /**
+   * Variable name available in expressions
+   */
+  name: string;
+  /**
+   * Type reference
+   */
+  type: TypeRef;
+  /**
+   * Description for hover/documentation
+   */
+  description?: string;
+  /**
+   * Example value for documentation
+   */
+  example?: string;
+}
+/**
+ * Schema for a type definition.
+ * These are reusable types that can be used in method signatures, variable types, and function signatures.
+ */
+interface TypeSchema {
+  /**
+   * Type name
+   */
+  name: string;
+  /**
+   * Type category
+   */
+  kind: "primitive" | "struct";
+  /**
+   * For structs: field definitions
+   */
+  fields?: ParamSchema[];
+  /**
+   * Description
+   */
+  description?: string;
+}
+/**
+ * Schema for a built-in CEL function.
+ *
+ * Functions are either **free functions** (`size(list)`) or
+ * **receiver methods** (`string.startsWith(prefix)`).
+ * When `receiverType` is set, the function is a method that can only be
+ * called on expressions of that type using dot-syntax.
+ */
+interface FunctionSchema {
+  /**
+   * Function name: "size", "string", "int", "startsWith"
+   */
+  name: string;
+  /**
+   * Function signature for display
+   *
+   * e.g., "size(list<T>): int" | "string.startsWith(prefix): bool"
+   */
+  signature: string;
+  /**
+   * Description
+   */
+  description?: string;
+  /**
+   * Parameter documentation (excludes the receiver for methods)
+   */
+  params: ParamSchema[];
+  /**
+   * Return type
+   */
+  returns: TypeRef;
+  /**
+   * When set, this function is a receiver method on the given type.
+   * E.g., `receiverType: "string"` means it is called as `expr.name(...)`.
+   */
+  receiverType?: TypeRef;
+}
+/**
+ * Schema for a CEL macro.
+ * Macros are syntactic sugar that expand to function calls.
+ */
+interface MacroSchema {
+  /**
+   * Macro name: "all", "exists", "map", "filter"
+   */
+  name: string;
+  /**
+   * Usage pattern
+   *
+   * e.g., "list.all(x, predicate)" | "list.map(x, transform)"
+   */
+  pattern: string;
+  /**
+   * Description
+   */
+  description?: string;
+  /**
+   * Example
+   */
+  example?: string;
+}
+//#endregion
+export { ContractSchema, FunctionSchema, MacroSchema, MethodSchema, ParamSchema, SELSchema, TypeRef, TypeSchema, VariableSchema };

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "@seljs/schema",
-  "version": "1.0.0",
+  "version": "1.0.1",
+  "repository": {
+    "url": "https://github.com/abinnovision/seljs"
+  },
   "license": "Apache-2.0",
   "author": {
     "name": "abi group GmbH",
     "email": "info@abigroup.io",
     "url": "https://abigroup.io/"
   },
-  "repository": {
-    "url": "https://github.com/abinnovision/seljs"
-  },
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./schema.json": "./dist/sel-schema.json"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist",
     "LICENSE.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsx scripts/generate-json-schema.ts",
+    "build": "tsdown && tsx scripts/generate-json-schema.ts",
     "format:check": "prettier --check '{{src,scripts}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
     "format:fix": "prettier --write '{{src,scripts}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
     "lint:check": "eslint '{{src,scripts}/**/*,*}.{t,j}s{,x}'",
@@ -51,6 +57,7 @@
     "eslint": "^9.39.4",
     "prettier": "^3.8.1",
     "ts-json-schema-generator": "^2.9.0",
+    "tsdown": "^0.21.3",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -1 +0,0 @@
-export * from "./types.js";

package/dist/types.d.ts

@@ -1,211 +0,0 @@
-import type { AbiFunction } from "abitype";
-/**
- * Type reference string used throughout the schema.
- * These are CEL type names like "int", "string", "bool", or custom types defined in the schema.
- * For parameterized types, use CEL syntax (e.g., "list<sol_address>").
- */
-export type TypeRef = string;
-/**
- * Root schema type for SEL expression language.
- * Contains all contracts, variables, types, functions, and macros available in a SEL environment.
- */
-export interface SELSchema {
-    /**
-     * Schema format version
-     */
-    version: string;
-    /**
-     * Available contracts and their methods
-     */
-    contracts: ContractSchema[];
-    /**
-     * Variables available in expressions (e.g., "user", "blockNumber")
-     */
-    variables: VariableSchema[];
-    /**
-     * Type definitions (primitives, structs, enums)
-     */
-    types: TypeSchema[];
-    /**
-     * Built-in CEL functions
-     */
-    functions: FunctionSchema[];
-    /**
-     * CEL macros (all, exists, map, filter, etc.)
-     */
-    macros: MacroSchema[];
-}
-/**
- * Schema for a contract with available methods.
- * Methods are view/pure functions that can be called in CEL expressions.
- */
-export interface ContractSchema {
-    /**
-     * Identifier used in expressions: erc20.balanceOf(...)
-     */
-    name: string;
-    /**
-     * Contract address (for display/documentation)
-     */
-    address: `0x${string}`;
-    /**
-     * Human-readable description
-     */
-    description?: string;
-    /**
-     * Available methods (view/pure functions only)
-     */
-    methods: MethodSchema[];
-}
-/**
- * Schema for a contract method.
- * Represents a view or pure function that can be called in CEL expressions.
- */
-export interface MethodSchema {
-    /**
-     * Method name: "balanceOf"
-     */
-    name: string;
-    /**
-     * From NatSpec @notice or custom
-     */
-    description?: string;
-    /**
-     * Method parameters
-     */
-    params: ParamSchema[];
-    /** Raw ABI function entry for viem encoding/decoding */
-    abi: AbiFunction;
-    /**
-     * Return type reference
-     */
-    returns: TypeRef;
-    /**
-     * For autocomplete grouping
-     */
-    category?: string;
-}
-/**
- * Schema for a method parameter or type field.
- * Used in methods, structs, and function signatures.
- */
-export interface ParamSchema {
-    /**
-     * Parameter name: "owner"
-     */
-    name: string;
-    /**
-     * Type reference: "address", "uint256", etc.
-     */
-    type: TypeRef;
-    /**
-     * From NatSpec @param or custom
-     */
-    description?: string;
-}
-/**
- * Schema for a variable available in CEL expressions.
- * Represents runtime context values like "user", "blockNumber", etc.
- */
-export interface VariableSchema {
-    /**
-     * Variable name available in expressions
-     */
-    name: string;
-    /**
-     * Type reference
-     */
-    type: TypeRef;
-    /**
-     * Description for hover/documentation
-     */
-    description?: string;
-    /**
-     * Example value for documentation
-     */
-    example?: string;
-}
-/**
- * Schema for a type definition.
- * These are reusable types that can be used in method signatures, variable types, and function signatures.
- */
-export interface TypeSchema {
-    /**
-     * Type name
-     */
-    name: string;
-    /**
-     * Type category
-     */
-    kind: "primitive" | "struct";
-    /**
-     * For structs: field definitions
-     */
-    fields?: ParamSchema[];
-    /**
-     * Description
-     */
-    description?: string;
-}
-/**
- * Schema for a built-in CEL function.
- *
- * Functions are either **free functions** (`size(list)`) or
- * **receiver methods** (`string.startsWith(prefix)`).
- * When `receiverType` is set, the function is a method that can only be
- * called on expressions of that type using dot-syntax.
- */
-export interface FunctionSchema {
-    /**
-     * Function name: "size", "string", "int", "startsWith"
-     */
-    name: string;
-    /**
-     * Function signature for display
-     *
-     * e.g., "size(list<T>): int" | "string.startsWith(prefix): bool"
-     */
-    signature: string;
-    /**
-     * Description
-     */
-    description?: string;
-    /**
-     * Parameter documentation (excludes the receiver for methods)
-     */
-    params: ParamSchema[];
-    /**
-     * Return type
-     */
-    returns: TypeRef;
-    /**
-     * When set, this function is a receiver method on the given type.
-     * E.g., `receiverType: "string"` means it is called as `expr.name(...)`.
-     */
-    receiverType?: TypeRef;
-}
-/**
- * Schema for a CEL macro.
- * Macros are syntactic sugar that expand to function calls.
- */
-export interface MacroSchema {
-    /**
-     * Macro name: "all", "exists", "map", "filter"
-     */
-    name: string;
-    /**
-     * Usage pattern
-     *
-     * e.g., "list.all(x, predicate)" | "list.map(x, transform)"
-     */
-    pattern: string;
-    /**
-     * Description
-     */
-    description?: string;
-    /**
-     * Example
-     */
-    example?: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,SAAS,EAAE,cAAc,EAAE,CAAC;IAE5B;;OAEG;IACH,SAAS,EAAE,cAAc,EAAE,CAAC;IAE5B;;OAEG;IACH,KAAK,EAAE,UAAU,EAAE,CAAC;IAEpB;;OAEG;IACH,SAAS,EAAE,cAAc,EAAE,CAAC;IAE5B;;OAEG;IACH,MAAM,EAAE,WAAW,EAAE,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,MAAM,EAAE,WAAW,EAAE,CAAC;IAEtB,wDAAwD;IACxD,GAAG,EAAE,WAAW,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC;IAE7B;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,MAAM,EAAE,WAAW,EAAE,CAAC;IAEtB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB"}