@bun-win32/shell32 1.0.0 → 1.0.1

package/index.ts

@@ -1,5 +1,3 @@
-import './runtime/extensions';
-
 import Shell32 from './structs/Shell32';
 
 export * from './types/Shell32';

package/package.json

@@ -1,7 +1,10 @@
 {
   "author": "Stev Peifer <stev@bell.net>",
   "bugs": {
-    "url": "https://github.com/bun-win32/shell32/issues"
+    "url": "https://github.com/ObscuritySRL/bun-win32/issues"
+  },
+  "dependencies": {
+    "@bun-win32/core": "workspace:*"
   },
   "description": "Zero-dependency, zero-overhead Win32 SHELL32 bindings for Bun (FFI) on Windows.",
   "devDependencies": {
@@ -17,13 +20,14 @@
     "typescript": "^5"
   },
   "private": false,
-  "homepage": "https://github.com/bun-win32/shell32#readme",
+  "homepage": "https://github.com/ObscuritySRL/bun-win32#readme",
   "repository": {
     "type": "git",
-    "url": "git://github.com/bun-win32/shell32.git"
+    "url": "git://github.com/ObscuritySRL/bun-win32.git",
+    "directory": "packages/shell32"
   },
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "./index.ts",
   "keywords": [
     "bun",
@@ -37,7 +41,6 @@
   ],
   "files": [
     "index.ts",
-    "runtime/*.ts",
     "structs/*.ts",
     "types/*.ts",
     "README.md"

package/structs/Shell32.ts

@@ -1,4 +1,5 @@
-import { type FFIFunction, FFIType, dlopen } from 'bun:ffi';
+import { type FFIFunction, FFIType } from 'bun:ffi';
+import { Win32 } from '@bun-win32/core';
 
 import type {
   ASSOC_FILTER,
@@ -104,85 +105,11 @@ import type {
  * Shell32.Preload(['SHGetKnownFolderPath', 'ShellExecuteW']);
  * ```
  */
-class Shell32 {
-  /**
-   * Lazily binds a single `shell32.dll` export and memoizes it on the class.
-   *
-   * If the symbol has already been bound (property is non-configurable), this is a no-op.
-   * Subsequent calls go directly through the memoized native function.
-   *
-   * @param method Exact export name from `Symbols`.
-   * @returns The bound native function, typed to the corresponding static method.
-   * @example
-   * ```ts
-   * // Internal usage: public wrappers call Load on first invocation
-   * // return Shell32.Load('SHGetKnownFolderPath')();
-   * ```
-   */
-  private static Load<T extends keyof typeof Shell32.Symbols>(method: T): (typeof Shell32)[T] {
-    const skip = Object.getOwnPropertyDescriptor(Shell32, method)?.configurable === false;
-
-    if (skip) {
-      return Shell32[method];
-    }
-
-    const library = dlopen('shell32.dll', { [method]: Shell32.Symbols[method] });
-
-    const propertyDescriptor = { configurable: false, value: library.symbols[method] };
-    Object.defineProperty(Shell32, method, propertyDescriptor);
-
-    return Shell32[method];
-  }
-
-  /**
-   * Eagerly binds one or more `shell32.dll` exports in a single `dlopen` call.
-   *
-   * When called with no arguments, every symbol in `Symbols` is bound.
-   * Already-bound symbols are skipped.
-   *
-   * @param methods Optional list of export names to preload. Defaults to all symbols.
-   * @example
-   * ```ts
-   * // Preload specific hot-path symbols
-   * Shell32.Preload(['ShellExecuteW', 'SHGetKnownFolderPath', 'SHGetFileInfoW']);
-   *
-   * // Or preload everything
-   * Shell32.Preload();
-   * ```
-   */
-  public static Preload(methods?: (keyof typeof Shell32.Symbols)[]): void {
-    methods ??= Object.keys(Shell32.Symbols) as (keyof typeof Shell32.Symbols)[];
-
-    const symbols = Object.fromEntries(
-      methods
-        .filter((method) => Object.getOwnPropertyDescriptor(Shell32, method)?.configurable !== false)
-        .map((method) => [method, Shell32.Symbols[method]])
-    );
-
-    const library = dlopen('shell32.dll', symbols);
-
-    const propertyDescriptorMap = Object.fromEntries(
-      Object.entries(library.symbols).map(([key, value]) => [key, { configurable: false, value }])
-    );
-
-    Object.defineProperties(Shell32, propertyDescriptorMap);
-  }
+class Shell32 extends Win32 {
+  protected static override name = 'shell32.dll';
 
-  // ---------------------------------------------------------------------------
-  // FFI symbol declarations — alphabetized
-  //
-  // FFIType reference:
-  //   FFIType.i32   → BOOL, int, LONG, HRESULT
-  //   FFIType.u32   → DWORD, UINT, ULONG
-  //   FFIType.u64   → HANDLE, HWND, HICON, HDROP, HINSTANCE, HKEY (returned as bigint)
-  //   FFIType.i64   → INT_PTR, LPARAM, LRESULT
-  //   FFIType.ptr   → any pointer parameter (LPVOID, LPWSTR, LPCWSTR, PIDLIST_ABSOLUTE, etc.)
-  //   FFIType.void  → void return
-  //
-  // Consult the Win32 docs for each function's exact signature:
-  //   https://learn.microsoft.com/en-us/windows/win32/api/{header}/nf-{header}-{functionname}
-  // ---------------------------------------------------------------------------
-  private static readonly Symbols = {
+  /** @inheritdoc */
+  protected static override readonly Symbols = {
     AssocCreateForClasses: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
     AssocGetDetailsOfPropKey: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
     CDefFolderMenu_Create2: { args: [FFIType.ptr, FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },

package/types/Shell32.ts

@@ -1,5 +1,7 @@
 import type { Pointer } from 'bun:ffi';
 
+export type { ACCESS_MASK, BOOL, BOOLEAN, BYTE, CHAR, DWORD, DWORD_PTR, HANDLE, HINSTANCE, HMODULE, HRESULT, HWND, INT, INT_PTR, LONG, LONG_PTR, LPARAM, LPBOOL, LPBYTE, LPCSTR, LPCVOID, LPCWSTR, LPDWORD, LPHANDLE, LPSECURITY_ATTRIBUTES, LPSTR, LPVOID, LPWSTR, LRESULT, NULL, PBYTE, PDWORD, PHANDLE, PULONG, PVOID, SHORT, SIZE_T, UINT, UINT_PTR, ULONG, ULONG_PTR, USHORT, VOID, WCHAR, WORD, WPARAM } from '@bun-win32/core';
+
 // ---------------------------------------------------------------------------
 // Win32 type aliases
 //
@@ -398,40 +400,24 @@ export enum StockIconId {
 }
 
 export type ASSOC_FILTER = number;
-export type BOOL = number;
-export type DWORD = number;
-export type DWORD_PTR = bigint;
 export type GETPROPERTYSTOREFLAGS = number;
-export type HANDLE = bigint;
 export type HDROP = bigint;
 export type HICON = bigint;
 export type HIMAGELIST = bigint;
-export type HINSTANCE = bigint;
 export type HKEY = bigint;
 export type HMENU = bigint;
 export type HPSXA = bigint;
-export type HRESULT = number;
-export type HWND = bigint;
-export type INT = number;
-export type INT_PTR = bigint;
-export type LONG = number;
-export type LPARAM = bigint;
 export type LPAUTO_SCROLL_DATA = Pointer;
 export type LPBROWSEINFOA = Pointer;
 export type LPBROWSEINFOW = Pointer;
 export type LPCITEMIDLIST = Pointer;
 export type LPCSFV = Pointer;
 export type LPCSHITEMID = Pointer;
-export type LPCSTR = Pointer;
-export type LPCVOID = Pointer;
-export type LPCWSTR = Pointer;
-export type LPDWORD = Pointer;
 export type LPFNADDPROPSHEETPAGE = Pointer;
 export type LPFNDFMCALLBACK = Pointer;
 export type LPITEMIDLIST = Pointer;
 export type LPPOINT = Pointer;
 export type LPRECT = Pointer;
-export type LPSECURITY_ATTRIBUTES = Pointer;
 export type LPSHCREATEPROCESSINFOW = Pointer;
 export type LPSHELLEXECUTEINFOA = Pointer;
 export type LPSHELLEXECUTEINFOW = Pointer;
@@ -443,11 +429,7 @@ export type LPSHFILEOPSTRUCTA = Pointer;
 export type LPSHFILEOPSTRUCTW = Pointer;
 export type LPSHELLFLAGSTATE = Pointer;
 export type LPSHSTOCKICONINFO = Pointer;
-export type LPSTR = Pointer;
-export type LPVOID = Pointer;
 export type LPWORD = Pointer;
-export type LPWSTR = Pointer;
-export type LRESULT = bigint;
 export type PAPPBARDATA = Pointer;
 export type PCABINETSTATE = Pointer;
 export type PCDEFCONTEXTMENU = Pointer;
@@ -472,15 +454,6 @@ export type PUITEMID_CHILD = Pointer;
 export type PWSTR = Pointer;
 export type SFGAOF = number;
 export type SIGDN = number;
-export type SIZE_T = bigint;
-export type UINT = number;
-export type UINT_PTR = bigint;
-export type ULONG = number;
-export type VOID = void;
-export type WCHAR = number;
-export type WORD = number;
-
-export type NULL = null;
 
 /**
  * A POINT struct packed into a 64-bit integer for by-value passing in the x64 ABI.

package/runtime/extensions.ts

@@ -1,210 +0,0 @@
-import { type Pointer, ptr } from 'bun:ffi';
-
-declare global {
-  /**
-   * Adds a native pointer property to all ArrayBuffer, Buffer, DataView, and TypedArray types.
-   *
-   * The `ptr` property returns a native pointer usable with Bun FFI.
-   *
-   * @example
-   * ```ts
-   * const arr = new Uint8Array([1, 2, 3]);
-   * nativeFunction(arr.ptr, arr.length);
-   * ```
-   */
-  interface ArrayBuffer {
-    /**
-     * Native pointer to ArrayBuffer memory for Bun FFI.
-     * @example
-     * ```ts
-     * const buf = new ArrayBuffer(8);
-     * nativeFunction(buf.ptr, buf.byteLength);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface BigInt64Array {
-    /**
-     * Native pointer to BigInt64Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new BigInt64Array([1n, 2n]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface BigUint64Array {
-    /**
-     * Native pointer to BigUint64Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new BigUint64Array([1n, 2n]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Buffer {
-    /**
-     * Native pointer to Buffer memory for Bun FFI.
-     * @example
-     * ```ts
-     * const buf = Buffer.from([1, 2, 3]);
-     * nativeFunction(buf.ptr, buf.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface DataView {
-    /**
-     * Native pointer to DataView memory for Bun FFI.
-     * @example
-     * ```ts
-     * const view = new DataView(new ArrayBuffer(4));
-     * nativeFunction(view.ptr, view.byteLength);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Float32Array {
-    /**
-     * Native pointer to Float32Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Float32Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Float64Array {
-    /**
-     * Native pointer to Float64Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Float64Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Int16Array {
-    /**
-     * Native pointer to Int16Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Int16Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Int32Array {
-    /**
-     * Native pointer to Int32Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Int32Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Int8Array {
-    /**
-     * Native pointer to Int8Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Int8Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface SharedArrayBuffer {
-    /**
-     * Native pointer to SharedArrayBuffer memory for Bun FFI.
-     * @example
-     * ```ts
-     * const buf = new SharedArrayBuffer(8);
-     * nativeFunction(buf.ptr, buf.byteLength);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Uint16Array {
-    /**
-     * Native pointer to Uint16Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Uint16Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Uint32Array {
-    /**
-     * Native pointer to Uint32Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Uint32Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Uint8Array {
-    /**
-     * Native pointer to Uint8Array memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Uint8Array([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-  interface Uint8ClampedArray {
-    /**
-     * Native pointer to Uint8ClampedArray memory for Bun FFI.
-     * @example
-     * ```ts
-     * const arr = new Uint8ClampedArray([1, 2, 3]);
-     * nativeFunction(arr.ptr, arr.length);
-     * ```
-     */
-    readonly ptr: Pointer;
-  }
-}
-
-/**
- * Installs the `ptr` property on all supported binary view prototypes.
- *
- * The property is non-enumerable and non-configurable. The getter calls `ptr(this)`.
- */
-const constructors = [ArrayBuffer, BigInt64Array, BigUint64Array, Buffer, DataView, Float32Array, Float64Array, Int16Array, Int32Array, Int8Array, SharedArrayBuffer, Uint16Array, Uint32Array, Uint8Array, Uint8ClampedArray] as const;
-
-constructors.forEach(
-  ({ prototype }) =>
-    !Object.getOwnPropertyDescriptor(prototype, 'ptr') &&
-    Object.defineProperty(prototype, 'ptr', {
-      configurable: false,
-      enumerable: false,
-      /**
-       * Returns a native pointer to the underlying memory.
-       * @returns Native pointer for Bun FFI.
-       * @example
-       * ```ts
-       * const arr = new Uint8Array([1, 2, 3]);
-       * nativeFunction(arr.ptr, arr.length);
-       * ```
-       */
-      get(this): Pointer {
-        return ptr(this);
-      },
-    })
-);
-
-export {};