@rspack/binding 0.0.0-01dbf86423-20221210100716

package/binding.d.ts

@@ -0,0 +1,406 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export interface RawCssPluginConfig {
+  /**
+   * ## Example
+   * ```rust,ignore
+   * RawCssOptions {
+   *   preset_env: vec!["Firefox > 10".into(), "chrome >=20".into()],
+   * }
+   * ```
+   * The preset_env will finally pass into [`browserslist::resolve`](https://docs.rs/browserslist-rs/latest/browserslist/fn.resolve.html).
+   * For detailed configuration, see https://docs.rs/browserslist-rs/latest/browserslist/
+   */
+  presetEnv?: Array<string>
+  modules?: RawCssModulesConfig
+}
+export interface RawCssModulesConfig {
+  localsConvention?: string
+  localIdentName?: string
+  exportsOnly?: boolean
+}
+export interface RawDecoratorOptions {
+  legacy: boolean
+  emitMetadata: boolean
+  useDefineForClassFields: boolean
+}
+/**
+ * It seems napi not support enum well
+*/
+export interface RawHtmlPluginConfig {
+  /** emitted file name in output path */
+  filename?: string | void
+  /** template html file */
+  template?: string
+  templateParameters?: Record<string, string>
+  /** `head`, `body` or None */
+  inject?: string | void
+  /** path or `auto` */
+  publicPath?: string
+  /** `blocking`, `defer`, or `module` */
+  scriptLoading?: string | void
+  /** entry_chunk_name (only entry chunks are supported) */
+  chunks?: Array<string>
+  excludedChunks?: Array<string>
+  sri?: string | void
+  minify?: boolean
+  title?: string
+  favicon?: string
+  meta?: Record<string, Record<string, string>>
+}
+export interface RawPostCssConfig {
+  pxtorem?: RawPxToRemConfig
+}
+export interface RawPxToRemConfig {
+  rootValue?: number
+  unitPrecision?: number
+  selectorBlackList?: Array<string>
+  propList?: Array<string>
+  replace?: boolean
+  mediaQuery?: boolean
+  minPixelValue?: number
+}
+export interface RawProgressPluginConfig {
+  prefix?: string
+}
+export interface RawReactOptions {
+  runtime?: string
+  importSource?: string
+  pragma?: string
+  pragmaFrag?: string
+  throwIfNamespace?: boolean
+  development?: boolean
+  useBuiltins?: boolean
+  useSpread?: boolean
+  refresh?: boolean
+}
+export interface Minification {
+  passes?: number
+  enable?: boolean
+}
+export interface RawBuiltins {
+  html?: Array<RawHtmlPluginConfig>
+  css?: RawCssPluginConfig
+  postcss?: RawPostCssConfig
+  minify?: Minification
+  polyfill?: boolean
+  browserslist?: Array<string>
+  define?: Record<string, string>
+  treeShaking?: boolean
+  sideEffects?: boolean
+  progress?: RawProgressPluginConfig
+  react?: RawReactOptions
+  decorator?: RawDecoratorOptions
+}
+export interface RawCacheOptions {
+  cacheType: string
+  maxGenerations: number
+  maxAge: number
+  profile: boolean
+  buildDependencies: Array<string>
+  cacheDirectory: string
+  cacheLocation: string
+  name: string
+  version: string
+}
+export interface RawDevServer {
+  hot?: boolean
+}
+export interface RawEntryItem {
+  import: Array<string>
+  runtime?: string
+}
+export interface RawExperiments {
+  lazyCompilation: boolean
+}
+/**
+ * `loader` is for js side loader, `builtin_loader` is for rust side loader,
+ * which is mapped to real rust side loader by [get_builtin_loader].
+ *
+ * `options` is
+ *   - a `None` on rust side and handled by js side `getOptions` when
+ * using with `loader`.
+ *   - a `Some(string)` on rust side, deserialized by `serde_json::from_str`
+ * and passed to rust side loader in [get_builtin_loader] when using with
+ * `builtin_loader`.
+ */
+export interface RawModuleRuleUse {
+  loader?: (...args: any[]) => any
+  builtinLoader?: string
+  options?: string
+  loaderName?: string
+}
+export interface RawModuleRuleCondition {
+  /** Condition can be either a `string` or `Regexp`. */
+  type: "string" | "regexp"
+  /**
+   * Based on the condition type, the value can be either a `string` or `Regexp`.
+   *  - "string": The value will be matched against the string.
+   *  - "regexp": The value will be matched against the raw regexp source from JS side.
+   */
+  matcher?: string
+}
+export interface RawModuleRule {
+  /**
+   * A condition matcher matching an absolute path.
+   * - String: To match the input must start with the provided string. I. e. an absolute directory path, or absolute path to the file.
+   * - Regexp: It's tested with the input.
+   */
+  test?: RawModuleRuleCondition
+  include?: Array<RawModuleRuleCondition>
+  exclude?: Array<RawModuleRuleCondition>
+  /**
+   * A condition matcher matching an absolute path.
+   * See `test` above
+   */
+  resource?: RawModuleRuleCondition
+  /**
+   * A condition matcher against the resource query.
+   * TODO: align with webpack's `?` prefixed `resourceQuery`
+   */
+  resourceQuery?: RawModuleRuleCondition
+  func?: (...args: any[]) => any
+  use?: Array<RawModuleRuleUse>
+  type?: "js" | "jsx" | "ts" | "tsx" | "css" | "json" | "asset" | "asset/resource" | "asset/source" | "asset/inline"
+}
+export interface RawAssetParserDataUrlOption {
+  maxSize?: number
+}
+export interface RawAssetParserOptions {
+  dataUrlCondition?: RawAssetParserDataUrlOption
+}
+export interface RawParserOptions {
+  asset?: RawAssetParserOptions
+}
+export interface RawModuleOptions {
+  rules: Array<RawModuleRule>
+  parser?: RawParserOptions
+}
+export interface RawOptimizationOptions {
+  splitChunks?: RawSplitChunksOptions
+  moduleIds?: string
+}
+export interface RawOutputOptions {
+  path?: string
+  publicPath?: string
+  assetModuleFilename?: string
+  filename?: string
+  chunkFilename?: string
+  cssFilename?: string
+  cssChunkFilename?: string
+  uniqueName?: string
+  library?: string
+}
+export interface RawResolveOptions {
+  preferRelative?: boolean
+  extensions?: Array<string>
+  mainFiles?: Array<string>
+  mainFields?: Array<string>
+  browserField?: boolean
+  conditionNames?: Array<string>
+  alias?: Record<string, string | false>
+  symlinks?: boolean
+  tsConfigPath?: string
+}
+export interface RawSnapshotStrategy {
+  hash: boolean
+  timestamp: boolean
+}
+export interface RawSnapshotOptions {
+  resolveBuildDependencies: RawSnapshotStrategy
+  buildDependencies: RawSnapshotStrategy
+  resolve: RawSnapshotStrategy
+  module: RawSnapshotStrategy
+}
+export interface RawSplitChunksOptions {
+  cacheGroups?: Record<string, RawCacheGroupOptions>
+  /** What kind of chunks should be selected. */
+  chunks?: string
+}
+export interface RawCacheGroupOptions {
+  test: string
+  /** What kind of chunks should be selected. */
+  chunks?: string
+  name: string
+}
+export interface RawStatsOptions {
+  colors: boolean
+}
+export interface RawOptions {
+  entry?: Record<string, RawEntryItem>
+  mode?: string
+  target?: string[]
+  context?: string
+  output?: RawOutputOptions
+  resolve?: RawResolveOptions
+  module?: RawModuleOptions
+  builtins?: RawBuiltins
+  externals?: Record<string, string>
+  externalsType?: string
+  devtool?: string
+  optimization?: RawOptimizationOptions
+  stats?: RawStatsOptions
+  devServer?: RawDevServer
+  snapshot?: RawSnapshotOptions
+  cache?: RawCacheOptions
+  experiments?: RawExperiments
+}
+export interface JsAssetInfoRelated {
+  sourceMap?: string
+}
+export interface JsAssetInfo {
+  /**
+   * if the asset can be long term cached forever (contains a hash)
+   * whether the asset is minimized
+   */
+  minimized: boolean
+  /**
+   * the value(s) of the full hash used for this asset
+   * the value(s) of the chunk hash used for this asset
+   * the value(s) of the module hash used for this asset
+   * the value(s) of the content hash used for this asset
+   * when asset was created from a source file (potentially transformed), the original filename relative to compilation context
+   * size in bytes, only set after asset has been emitted
+   * when asset is only used for development and doesn't count towards user-facing assets
+   */
+  development: boolean
+  /** when asset ships data for updating an existing application (HMR) */
+  hotModuleReplacement: boolean
+  /**
+   * when asset is javascript and an ESM
+   * related object to other assets, keyed by type of relation (only points from parent to child)
+   */
+  related: JsAssetInfoRelated
+}
+export interface JsAsset {
+  name: string
+  source: JsCompatSource
+  info: JsAssetInfo
+}
+export interface JsChunk {
+  files: Array<string>
+}
+export interface JsChunkGroup {
+  chunks: Array<JsChunk>
+}
+export interface JsHooks {
+  done: (...args: any[]) => any
+  processAssets: (...args: any[]) => any
+  compilation: (...args: any[]) => any
+  thisCompilation: (...args: any[]) => any
+}
+export interface JsCompatSource {
+  /** Whether the underlying data structure is a `RawSource` */
+  isRaw: boolean
+  /** Whether the underlying value is a buffer or string */
+  isBuffer: boolean
+  source: Buffer
+  map?: Buffer
+}
+export interface JsStatsError {
+  message: string
+  formatted: string
+}
+export interface JsStatsWarning {
+  message: string
+  formatted: string
+}
+export interface JsStatsAsset {
+  type: string
+  name: string
+  size: number
+  chunks: Array<string>
+  chunkNames: Array<string>
+  info: JsStatsAssetInfo
+  emitted: boolean
+}
+export interface JsStatsAssetInfo {
+  development: boolean
+  hotModuleReplacement: boolean
+}
+export interface JsStatsModule {
+  type: string
+  moduleType: string
+  identifier: string
+  name: string
+  id: string
+  chunks: Array<string>
+  size: number
+}
+export interface JsStatsChunk {
+  type: string
+  files: Array<string>
+  id: string
+  entry: boolean
+  initial: boolean
+  names: Array<string>
+  size: number
+}
+export interface JsStatsEntrypointAsset {
+  name: string
+  size: number
+}
+export interface JsStatsEntrypoint {
+  name: string
+  assets: Array<JsStatsEntrypointAsset>
+  chunks: Array<string>
+  assetsSize: number
+}
+export interface JsStatsCompilation {
+  assets: Array<JsStatsAsset>
+  modules: Array<JsStatsModule>
+  chunks: Array<JsStatsChunk>
+  entrypoints: Array<JsStatsEntrypoint>
+  errors: Array<JsStatsError>
+  errorsCount: number
+  warnings: Array<JsStatsWarning>
+  warningsCount: number
+}
+export function initCustomTraceSubscriber(): void
+export class JsCompilation {
+  updateAsset(filename: string, newSourceOrFunction: JsCompatSource | ((source: JsCompatSource) => JsCompatSource), assetInfoUpdateOrFunction?: JsAssetInfo | ((assetInfo: JsAssetInfo) => JsAssetInfo)): void
+  getAssets(): Readonly<JsAsset>[]
+  getAsset(name: string): JsAsset | null
+  emitAsset(filename: string, source: JsCompatSource, assetInfo: JsAssetInfo): void
+  deleteAsset(filename: string): void
+  get assets(): Record<string, JsCompatSource>
+  get entrypoints(): Record<string, JsChunkGroup>
+}
+export class Rspack {
+  constructor(options: RawOptions, jsHooks?: JsHooks | undefined | null)
+  /**
+   * Build with the given option passed to the constructor
+   *
+   * Warning:
+   * Calling this method recursively might cause a deadlock.
+   */
+  unsafe_build(callback: (err: null | Error, result: JsStatsCompilation) => void): void
+  /**
+   * Rebuild with the given option passed to the constructor
+   *
+   * Warning:
+   * Calling this method recursively will cause a deadlock.
+   */
+  unsafe_rebuild(callback: (err: null | Error, result: Record<string, {content: string, kind: number}>) => void): void
+  /**
+   * Get the last compilation
+   *
+   * Warning:
+   *
+   * Calling this method under the build or rebuild method might cause a deadlock.
+   *
+   * **Note** that this method is not safe if you cache the _JsCompilation_ on the Node side, as it will be invalidated by the next build and accessing a dangling ptr is a UB.
+   */
+  unsafe_last_compilation(f: (arg0: JsCompilation) => void): void
+  /**
+   * Destroy the compiler
+   *
+   * Warning:
+   *
+   * Anything related to this compiler will be invalidated after this method is called.
+   */
+  unsafe_drop(): void
+}

package/binding.js

@@ -0,0 +1,221 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      return readFileSync('/usr/bin/ldd', 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.android-arm64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rspack.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@rspack/binding-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-x64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-ia32-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-arm64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.darwin-x64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.darwin-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'rspack.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rspack.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@rspack/binding-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-x64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-x64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm-gnueabihf.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('@rspack/binding-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports.default = module.exports = nativeBinding

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@rspack/binding",
+  "version": "0.0.0-01dbf86423-20221210100716",
+  "description": "Node binding for rspack",
+  "main": "binding.js",
+  "types": "binding.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "binding.js",
+    "binding.d.ts",
+    "*.node"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.6.2",
+    "why-is-node-running": "2.2.1",
+    "npm-run-all": "4.1.5"
+  },
+  "scripts": {
+    "build:debug": "napi build --platform --js false --dts binding.d.ts --config napirs.rc.json",
+    "build:debug:x64": "napi build --platform --js false --dts binding.d.ts --config napirs.rc.json --target x86_64-apple-darwin",
+    "build:release:all": "run-p build:release build:release:x64 build:release:linux",
+    "build:release": "napi build --release --platform --js false --dts binding.d.ts --config napirs.rc.json",
+    "build:release:x64": "napi build --release --platform --js false --dts binding.d.ts --config napirs.rc.json --target x86_64-apple-darwin",
+    "build:release:linux": "napi build --release --platform --js false --dts binding.d.ts --config napirs.rc.json --zig --target x86_64-unknown-linux-gnu --zig-abi-suffix=2.17"
+  }
+}