objcjs-types 0.5.1 → 0.5.2

package/generator/ast-parser.ts

@@ -122,6 +122,17 @@ export interface ObjCFunction {
   frameworkName: string;
 }
 
+// --- Numeric constant types ---
+
+export interface ObjCNumericConstant {
+  /** The constant name (e.g., "NSVariableStatusItemLength") */
+  name: string;
+  /** The numeric value */
+  value: number;
+  /** Whether the value is a floating-point type (CGFloat, double, float) vs integer (NSInteger, etc.) */
+  isFloat: boolean;
+}
+
 // --- Helpers for extracting doc comments and deprecation info ---
 
 /**
@@ -1399,6 +1410,127 @@ function extractIntegerValue(node: ClangASTNode): string | null {
   return val !== null ? String(val) : null;
 }
 
+/**
+ * Extract a numeric value (integer or floating-point) from a VarDecl's initializer expression tree.
+ * Handles IntegerLiteral, FloatingLiteral, UnaryOperator("-"), and ImplicitCastExpr wrappers.
+ * Returns the numeric value, or null if it can't be extracted.
+ */
+function extractNumericValue(node: ClangASTNode): number | null {
+  if (!node.inner) return null;
+
+  function evaluate(n: ClangASTNode): number | null {
+    if (n.kind === "IntegerLiteral" && n.value !== undefined) {
+      return parseInt(n.value, 10);
+    }
+    if (n.kind === "FloatingLiteral" && n.value !== undefined) {
+      return parseFloat(n.value);
+    }
+    if (n.kind === "UnaryOperator" && (n as any).opcode === "-" && n.inner?.length === 1) {
+      const operand = evaluate(n.inner[0]!);
+      return operand !== null ? -operand : null;
+    }
+    // Walk through transparent wrappers (ImplicitCastExpr, ParenExpr, ConstantExpr, etc.)
+    if (n.inner?.length === 1) {
+      return evaluate(n.inner[0]!);
+    }
+    // Try all children for multi-child wrappers
+    if (n.inner) {
+      for (const child of n.inner) {
+        const val = evaluate(child);
+        if (val !== null) return val;
+      }
+    }
+    return null;
+  }
+
+  return evaluate(node);
+}
+
+/**
+ * Parse a clang AST root node and extract standalone numeric constants.
+ *
+ * These are `static const` VarDecl nodes with numeric types (CGFloat, double, float,
+ * NSInteger, NSUInteger, NSTimeInterval, int, long) that are NOT linked to a
+ * NS_TYPED_EXTENSIBLE_ENUM typedef via `typeAliasDeclId`.
+ *
+ * Examples:
+ * - `static const CGFloat NSVariableStatusItemLength = -1;`
+ * - `static const NSInteger NSSearchFieldRecentsTitleMenuItemTag = 1000;`
+ *
+ * @param targetConstants - Set of constant names to extract (from discovery)
+ */
+export function parseNumericConstants(
+  root: ClangASTNode,
+  targetConstants: Set<string>
+): Map<string, ObjCNumericConstant> {
+  const constants = new Map<string, ObjCNumericConstant>();
+  if (targetConstants.size === 0) return constants;
+
+  // Collect all TypedefDecl ids that are NS_TYPED_EXTENSIBLE_ENUM / NS_TYPED_ENUM
+  // so we can exclude VarDecls that are already handled by parseIntegerTypedEnums.
+  const typedEnumIds = new Set<string>();
+  function walkForTypedEnumTypedefs(node: ClangASTNode): void {
+    if (node.kind === "TypedefDecl" && node.id) {
+      const hasSwiftNewType = node.inner?.some((child) => child.kind === "SwiftNewTypeAttr") ?? false;
+      if (hasSwiftNewType) {
+        typedEnumIds.add(node.id);
+      }
+    }
+    if (node.inner) {
+      for (const child of node.inner) {
+        walkForTypedEnumTypedefs(child);
+      }
+    }
+  }
+
+  function walkForConstants(node: ClangASTNode): void {
+    if (node.kind === "VarDecl" && node.name && node.storageClass === "static" && targetConstants.has(node.name)) {
+      // Skip VarDecls linked to NS_TYPED_EXTENSIBLE_ENUM typedefs (handled by parseIntegerTypedEnums)
+      if (node.type?.typeAliasDeclId && typedEnumIds.has(node.type.typeAliasDeclId)) {
+        return;
+      }
+
+      // Check that the type is a const numeric type
+      const qualType = node.type?.qualType ?? "";
+      const desugared = node.type?.desugaredQualType ?? "";
+      const isConstNumeric =
+        /\bconst\b/.test(qualType) &&
+        (/\b(CGFloat|double|float|NSInteger|NSUInteger|NSTimeInterval|int|long)\b/.test(qualType) ||
+          /\b(double|float|long|int|unsigned long)\b/.test(desugared));
+
+      if (!isConstNumeric) return;
+
+      const value = extractNumericValue(node);
+      if (value === null) return;
+
+      // Determine if this is a float type
+      const isFloat =
+        /\b(CGFloat|double|float|NSTimeInterval)\b/.test(qualType) || /\b(double|float)\b/.test(desugared);
+
+      if (!constants.has(node.name)) {
+        constants.set(node.name, {
+          name: node.name,
+          value,
+          isFloat
+        });
+      }
+    }
+
+    if (node.inner) {
+      for (const child of node.inner) {
+        walkForConstants(child);
+      }
+    }
+  }
+
+  // First pass: find typed enum typedef IDs to exclude
+  walkForTypedEnumTypedefs(root);
+  // Second pass: find matching VarDecl constants
+  walkForConstants(root);
+
+  return constants;
+}
+
 // --- Struct parsing ---
 
 /**

package/generator/discover.ts

@@ -15,6 +15,8 @@ export interface DiscoveryResult {
   integerEnums: Map<string, string>;
   /** Maps string enum name → header file name (without .h extension) */
   stringEnums: Map<string, string>;
+  /** Maps numeric constant name → header file name (without .h extension) */
+  numericConstants: Map<string, string>;
 }
 
 /** Matches `@interface ClassName` — captures class name */
@@ -58,6 +60,18 @@ const NS_INTEGER_TYPED_ENUM_RE = /typedef\s+NSU?Integer\s+(\w+)\s+NS_(?:TYPED_EX
  */
 const NS_ERROR_ENUM_RE = /typedef\s+NS_ERROR_ENUM\s*\(\s*\w+\s*,\s*(\w+)\s*\)/;
 
+/**
+ * Matches standalone `static const` numeric variable declarations.
+ * These are constants like `NSVariableStatusItemLength`, `NSEventDurationForever`, etc.
+ * Captures the constant name from declarations like:
+ * `static const CGFloat NSVariableStatusItemLength = -1;`
+ * `static const NSInteger NSSearchFieldRecentsTitleMenuItemTag = 1000;`
+ * `static const CGFloat NSStackViewSpacingUseDefault API_AVAILABLE(macos(10.9)) = FLT_MAX;`
+ * Allows optional API_AVAILABLE / NS_AVAILABLE / etc. attributes between name and `=`.
+ */
+const STATIC_CONST_NUMERIC_RE =
+  /static\s+(?:const\s+)?(?:CGFloat|double|float|NSInteger|NSUInteger|NSTimeInterval|int|long)\s+(?:const\s+)?(\w+)\b[^;]*=/;
+
 /**
  * Scan all .h files in a framework's Headers directory and discover
  * every ObjC class and protocol declaration, mapping each to its header file.
@@ -71,6 +85,7 @@ export async function discoverFramework(headersPath: string): Promise<DiscoveryR
   const protocols = new Map<string, string>();
   const integerEnums = new Map<string, string>();
   const stringEnums = new Map<string, string>();
+  const numericConstants = new Map<string, string>();
 
   const entries = await readdir(headersPath);
   const headerFiles = entries.filter((f) => f.endsWith(".h")).sort();
@@ -141,8 +156,18 @@ export async function discoverFramework(headersPath: string): Promise<DiscoveryR
           integerEnums.set(name, headerName);
         }
       }
+
+      // --- Standalone numeric constants ---
+      // e.g., `static const CGFloat NSVariableStatusItemLength = -1;`
+      const numericConstMatch = STATIC_CONST_NUMERIC_RE.exec(line);
+      if (numericConstMatch) {
+        const name = numericConstMatch[1]!;
+        if (!numericConstants.has(name)) {
+          numericConstants.set(name, headerName);
+        }
+      }
     }
   }
 
-  return { classes, protocols, integerEnums, stringEnums };
+  return { classes, protocols, integerEnums, stringEnums, numericConstants };
 }

package/generator/emitter.ts

@@ -10,7 +10,8 @@ import type {
   ObjCIntegerEnum,
   ObjCStringEnum,
   ObjCStringEnumValue,
-  ObjCFunction
+  ObjCFunction,
+  ObjCNumericConstant
 } from "./ast-parser.ts";
 import type { FrameworkConfig } from "./frameworks.ts";
 import {
@@ -1809,6 +1810,36 @@ export function emitFunctionsFile(
   return lines.join("\n");
 }
 
+/**
+ * Generate a constants.ts file for a framework.
+ * Emits `export const NAME: number = VALUE;` for each standalone numeric constant.
+ *
+ * Example output:
+ * ```ts
+ * // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+ *
+ * export const NSVariableStatusItemLength: number = -1;
+ * export const NSSquareStatusItemLength: number = -2;
+ * ```
+ */
+export function emitConstantsFile(constants: ObjCNumericConstant[]): string {
+  const lines: string[] = [];
+  lines.push(AUTOGEN_HEADER);
+  lines.push("");
+
+  // Sort constants alphabetically for deterministic output
+  const sorted = [...constants].sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const constant of sorted) {
+    // Format the value: use integer representation when possible for cleaner output
+    const valueStr = Number.isInteger(constant.value) ? String(constant.value) : String(constant.value);
+    lines.push(`export const ${constant.name}: number = ${valueStr};`);
+  }
+  lines.push("");
+
+  return lines.join("\n");
+}
+
 /**
  * Extract class, struct, and enum references from a mapped TS type string
  * (used by emitFunctionsFile for collecting imports).
@@ -1878,7 +1909,7 @@ export function emitFrameworkIndex(
   // as the framework (e.g. IOSurface framework has an IOSurface class)
   const classNames = new Set(generatedClasses);
   const libVar = classNames.has(framework.name) ? `${framework.name}_lib` : framework.name;
-  lines.push(`export const ${libVar} = new NobjcLibrary("${framework.libraryPath}");`);
+  lines.push(`export const ${libVar} = /* @__PURE__ */ new NobjcLibrary("${framework.libraryPath}");`);
   lines.push("");
 
   // Build a reverse lookup: className → canonical filename for collision groups
@@ -1894,7 +1925,7 @@ export function emitFrameworkIndex(
   for (const className of generatedClasses) {
     const fileName = classToFile.get(className) ?? className;
     lines.push(`import type { _${className} } from "./${fileName}.js";`);
-    lines.push(`export const ${className} = _bindClass<typeof _${className}>(${libVar}, "${className}");`);
+    lines.push(`export const ${className} = /* @__PURE__ */ _bindClass<typeof _${className}>(${libVar}, "${className}");`);
     lines.push(`export type { _${className} };`);
     lines.push("");
   }

package/generator/frameworks.ts

@@ -31,6 +31,8 @@ export interface FrameworkConfig extends FrameworkBase {
   integerEnums: string[];
   /** All discovered string enum names (NS_TYPED_EXTENSIBLE_ENUM etc.) */
   stringEnums: string[];
+  /** All discovered standalone numeric constant names */
+  numericConstants: string[];
   /** Maps class name → header file name (without .h) */
   classHeaders: Map<string, string>;
   /** Maps protocol name → header file name (without .h) */
@@ -39,6 +41,8 @@ export interface FrameworkConfig extends FrameworkBase {
   integerEnumHeaders: Map<string, string>;
   /** Maps string enum name → header file name (without .h) */
   stringEnumHeaders: Map<string, string>;
+  /** Maps numeric constant name → header file name (without .h) */
+  numericConstantHeaders: Map<string, string>;
 }
 
 export const SDK_PATH =

package/generator/index.ts

@@ -24,7 +24,8 @@ import type {
   ObjCStringEnum,
   ObjCStruct,
   ObjCStructAlias,
-  ObjCFunction
+  ObjCFunction,
+  ObjCNumericConstant
 } from "./ast-parser.ts";
 import {
   setKnownClasses,
@@ -51,6 +52,7 @@ import {
   emitIntegerEnumFile,
   emitStringEnumFile,
   emitFunctionsFile,
+  emitConstantsFile,
   groupCaseCollisions
 } from "./emitter.ts";
 import type { StructDef, StructFieldDef } from "./emitter.ts";
@@ -123,7 +125,8 @@ async function main(): Promise<void> {
       discovery.classes.size === 0 &&
       discovery.protocols.size === 0 &&
       discovery.integerEnums.size === 0 &&
-      discovery.stringEnums.size === 0
+      discovery.stringEnums.size === 0 &&
+      discovery.numericConstants.size === 0
     )
       continue;
 
@@ -133,15 +136,20 @@ async function main(): Promise<void> {
       protocols: [...discovery.protocols.keys()].sort(),
       integerEnums: [...discovery.integerEnums.keys()].sort(),
       stringEnums: [...discovery.stringEnums.keys()].sort(),
+      numericConstants: [...discovery.numericConstants.keys()].sort(),
       classHeaders: discovery.classes,
       protocolHeaders: discovery.protocols,
       integerEnumHeaders: discovery.integerEnums,
-      stringEnumHeaders: discovery.stringEnums
+      stringEnumHeaders: discovery.stringEnums,
+      numericConstantHeaders: discovery.numericConstants
     };
     frameworks.push(fw);
 
     const enumCount = fw.integerEnums.length + fw.stringEnums.length;
-    console.log(`  ${fw.name}: ${fw.classes.length} classes, ${fw.protocols.length} protocols, ${enumCount} enums`);
+    const constStr = fw.numericConstants.length > 0 ? `, ${fw.numericConstants.length} constants` : "";
+    console.log(
+      `  ${fw.name}: ${fw.classes.length} classes, ${fw.protocols.length} protocols, ${enumCount} enums${constStr}`
+    );
   }
   const discoveryTime = ((performance.now() - globalStart) / 1000).toFixed(1);
   console.log(`  Discovery completed in ${discoveryTime}s\n`);
@@ -209,6 +217,7 @@ async function main(): Promise<void> {
     protocolTargets: string[];
     integerEnumTargets: string[];
     stringEnumTargets: string[];
+    numericConstantTargets: string[];
     preIncludes: string[];
   }
 
@@ -239,6 +248,7 @@ async function main(): Promise<void> {
     const protocolTargets: string[] = [];
     const integerEnumTargets: string[] = [];
     const stringEnumTargets: string[] = [];
+    const numericConstantTargets: string[] = [];
 
     // --- Class targets ---
     for (const className of fw.classes) {
@@ -284,13 +294,21 @@ async function main(): Promise<void> {
       stringEnumTargets.push(enumName);
     }
 
+    // --- Numeric constant targets ---
+    // No header validation needed — constants are discovered from the same headers
+    // that are already included in allFrameworkHeaders.
+    for (const constName of fw.numericConstants) {
+      numericConstantTargets.push(constName);
+    }
+
     // Only create a batch task if there are targets to parse
     if (
       allFrameworkHeaders.length > 0 &&
       (classTargets.length > 0 ||
         protocolTargets.length > 0 ||
         integerEnumTargets.length > 0 ||
-        stringEnumTargets.length > 0)
+        stringEnumTargets.length > 0 ||
+        numericConstantTargets.length > 0)
     ) {
       batchTasks.push({
         frameworkName: fw.name,
@@ -299,6 +317,7 @@ async function main(): Promise<void> {
         protocolTargets,
         integerEnumTargets,
         stringEnumTargets,
+        numericConstantTargets,
         preIncludes
       });
     }
@@ -365,7 +384,8 @@ async function main(): Promise<void> {
         task.integerEnumTargets,
         task.stringEnumTargets,
         task.preIncludes,
-        task.frameworkName
+        task.frameworkName,
+        task.numericConstantTargets
       )
       .then((result) => {
         trackProgress(task.frameworkName);
@@ -544,6 +564,22 @@ async function main(): Promise<void> {
     }
   }
 
+  // Organize parsed numeric constants by framework
+  const frameworkNumericConstants = new Map<string, Map<string, ObjCNumericConstant>>();
+  for (const entry of allResults) {
+    if (entry.isExtra) continue;
+    if (entry.error || !entry.result) continue;
+    if (entry.result.numericConstants.size === 0) continue;
+
+    if (!frameworkNumericConstants.has(entry.task.frameworkName)) {
+      frameworkNumericConstants.set(entry.task.frameworkName, new Map());
+    }
+    const fwConsts = frameworkNumericConstants.get(entry.task.frameworkName)!;
+    for (const [name, constant] of entry.result.numericConstants) {
+      fwConsts.set(name, constant);
+    }
+  }
+
   // Collect all parsed structs and struct aliases across all headers
   const allParsedStructs = new Map<string, ObjCStruct>();
   const allStructAliases: ObjCStructAlias[] = [];
@@ -1228,6 +1264,15 @@ async function main(): Promise<void> {
       hasFunctions = true;
     }
 
+    // Emit constants file (standalone numeric constants)
+    const fwConsts = frameworkNumericConstants.get(framework.name);
+    let hasConstants = false;
+    if (fwConsts && fwConsts.size > 0) {
+      const constantsContent = emitConstantsFile([...fwConsts.values()]);
+      await writeFile(join(frameworkDir, "constants.ts"), constantsContent);
+      hasConstants = true;
+    }
+
     // Emit framework index
     const indexContent = emitFrameworkIndex(
       framework,
@@ -1246,8 +1291,9 @@ async function main(): Promise<void> {
     const totalEnumCount =
       generatedIntegerEnums.length + generatedStringEnums.length + generatedStringEnumsTypeOnly.length;
     const funcCountStr = hasFunctions ? ` + ${fwFuncs!.size} functions` : "";
+    const constCountStr = hasConstants ? ` + ${fwConsts!.size} constants` : "";
     console.log(
-      `  ${framework.name}: ${generatedClasses.length} class files + ${generatedProtocols.length} protocol files + ${totalEnumCount} enum files${funcCountStr} + index.ts`
+      `  ${framework.name}: ${generatedClasses.length} class files + ${generatedProtocols.length} protocol files + ${totalEnumCount} enum files${funcCountStr}${constCountStr} + index.ts`
     );
   }
 
@@ -1307,21 +1353,27 @@ async function main(): Promise<void> {
   let totalProtocols = 0;
   let totalEnums = 0;
   let totalFunctions = 0;
+  let totalConstants = 0;
   for (const fw of frameworksToProcess) {
     const dir = join(SRC_DIR, fw.name);
     const classCount = fw.classes.filter((c) => existsSync(join(dir, `${c}.ts`))).length;
     const protoCount = fw.protocols.filter((p) => existsSync(join(dir, `${p}.ts`))).length;
     const enumCount = [...fw.integerEnums, ...fw.stringEnums].filter((e) => existsSync(join(dir, `${e}.ts`))).length;
     const funcCount = frameworkFunctions.get(fw.name)?.size ?? 0;
+    const constCount = frameworkNumericConstants.get(fw.name)?.size ?? 0;
     const funcStr = funcCount > 0 ? `, ${funcCount} functions` : "";
-    console.log(`  ${fw.name}: ${classCount} classes, ${protoCount} protocols, ${enumCount} enums${funcStr}`);
+    const constStr = constCount > 0 ? `, ${constCount} constants` : "";
+    console.log(
+      `  ${fw.name}: ${classCount} classes, ${protoCount} protocols, ${enumCount} enums${funcStr}${constStr}`
+    );
     totalClasses += classCount;
     totalProtocols += protoCount;
     totalEnums += enumCount;
     totalFunctions += funcCount;
+    totalConstants += constCount;
   }
   console.log(
-    `  Total: ${totalClasses} classes, ${totalProtocols} protocols, ${totalEnums} enums, ${totalFunctions} functions`
+    `  Total: ${totalClasses} classes, ${totalProtocols} protocols, ${totalEnums} enums, ${totalFunctions} functions, ${totalConstants} constants`
   );
 
   // Clean up the compiled ObjC helper binary

package/generator/parse-worker.ts

@@ -18,7 +18,8 @@ import {
   parseStringEnums,
   parseStructs,
   parseTypedefs,
-  parseFunctions
+  parseFunctions,
+  parseNumericConstants
 } from "./ast-parser.ts";
 
 /**
@@ -95,6 +96,10 @@ self.onmessage = async (event: MessageEvent) => {
       const frameworkHeaderPathSet = new Set<string>(headerPaths);
       const functions = parseFunctions(ast, frameworkHeaderPathSet, msg.frameworkName ?? "");
 
+      // Parse standalone numeric constants
+      const numericConstantTargetSet = new Set<string>(msg.numericConstantTargets ?? []);
+      const numericConstants = parseNumericConstants(ast, numericConstantTargetSet);
+
       postMessage({
         id: msg.id,
         type: "batch-result",
@@ -106,6 +111,7 @@ self.onmessage = async (event: MessageEvent) => {
         structAliases: structResult.aliases,
         typedefs: [...typedefs.entries()],
         functions: [...functions.entries()],
+        numericConstants: [...numericConstants.entries()],
         // Report what was found vs expected for logging
         foundClasses: classes.size,
         foundProtocols: protocols.size,
@@ -209,7 +215,8 @@ self.onmessage = async (event: MessageEvent) => {
         structs: [...structResult.structs.entries()],
         structAliases: structResult.aliases,
         typedefs: [...typedefs.entries()],
-        functions: [] // parse-all is used for extra headers which don't need function parsing
+        functions: [], // parse-all is used for extra headers which don't need function parsing
+        numericConstants: [] // parse-all is used for extra headers which don't need constant parsing
       });
     } else if (msg.type === "parse-classes") {
       const targetSet = new Set<string>(msg.targets);

package/generator/worker-pool.ts

@@ -14,7 +14,8 @@ import type {
   ObjCStringEnum,
   ObjCStruct,
   ObjCStructAlias,
-  ObjCFunction
+  ObjCFunction,
+  ObjCNumericConstant
 } from "./ast-parser.ts";
 
 /** Result from a unified parse-all task (classes + protocols + enums + structs from one clang invocation) */
@@ -35,6 +36,8 @@ export interface UnifiedParseResult {
   typedefs: Map<string, string>;
   /** Parsed C function declarations (function name → ObjCFunction) */
   functions: Map<string, ObjCFunction>;
+  /** Parsed standalone numeric constants (constant name → ObjCNumericConstant) */
+  numericConstants: Map<string, ObjCNumericConstant>;
 }
 
 export interface ClassParseResult {
@@ -248,7 +251,8 @@ export class WorkerPool {
       structs: new Map(result.structs ?? []),
       structAliases: result.structAliases ?? [],
       typedefs: new Map(result.typedefs ?? []),
-      functions: new Map(result.functions ?? [])
+      functions: new Map(result.functions ?? []),
+      numericConstants: new Map(result.numericConstants ?? [])
     };
   }
 
@@ -271,7 +275,8 @@ export class WorkerPool {
     integerEnumTargets: string[],
     stringEnumTargets: string[],
     preIncludes: string[],
-    frameworkName?: string
+    frameworkName?: string,
+    numericConstantTargets?: string[]
   ): Promise<UnifiedParseResult> {
     const result = await this.dispatch({
       id: this.nextId++,
@@ -282,7 +287,8 @@ export class WorkerPool {
       integerEnumTargets,
       stringEnumTargets,
       preIncludes,
-      frameworkName
+      frameworkName,
+      numericConstantTargets
     });
     return {
       classes: new Map(result.classes),
@@ -292,7 +298,8 @@ export class WorkerPool {
       structs: new Map(result.structs ?? []),
       structAliases: result.structAliases ?? [],
       typedefs: new Map(result.typedefs ?? []),
-      functions: new Map(result.functions ?? [])
+      functions: new Map(result.functions ?? []),
+      numericConstants: new Map(result.numericConstants ?? [])
     };
   }
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "objcjs-types",
-  "version": "0.5.1",
-  "description": "Auto-generated TypeScript type declarations for macOS Objective-C frameworks",
+  "version": "0.5.2",
+  "description": "Auto-generated TypeScript type declarations for macOS Objective-C frameworks that supplement objc-js",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -33,6 +34,10 @@
     "./*/functions": {
       "types": "./dist/*/functions.d.ts",
       "default": "./dist/*/functions.js"
+    },
+    "./*/constants": {
+      "types": "./dist/*/constants.d.ts",
+      "default": "./dist/*/constants.js"
     }
   },
   "files": [
@@ -63,7 +68,7 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "objc-js": "^1.1.0",
+    "objc-js": "^1.3.1",
     "typescript": "^5"
   },
   "devDependencies": {