feat: basic transform

.gitignore

@@ -4,3 +4,4 @@ node_modules
 dist
 coverage
 .profile
+temp

src/index.ts

@@ -2,8 +2,8 @@ import { getRollupPlugin } from './rollup'
 import { UnpluginOptions, UnpluginInstance } from './types'
 import { getWebpackPlugin } from './webpack'
 
-export function defineUnplugin<UserOptions = {}, ResolvedContext = UserOptions> (
-  options: UnpluginOptions<UserOptions, ResolvedContext>
+export function defineUnplugin<UserOptions = {}> (
+  options: UnpluginOptions<UserOptions>
 ): UnpluginInstance<UserOptions> {
   return {
     get rollup () {

src/rollup.ts

@@ -1,14 +1,14 @@
 import { UnpluginInstance, UnpluginOptions } from './types'
 
-export function getRollupPlugin <UserOptions = {}, ResolvedContext = UserOptions> (
-  options: UnpluginOptions<UserOptions, ResolvedContext>
+export function getRollupPlugin <UserOptions = {}> (
+  options: UnpluginOptions<UserOptions>
 ): UnpluginInstance<UserOptions>['rollup'] {
   return (userOptions?: UserOptions) => {
-    const context = options.setup(userOptions)
-    const hooks = options.hooks(context)
+    const hooks = options.setup(userOptions)
 
     return {
       name: options.name,
+      enforce: options.enforce,
       transform (code, id) {
         if (!hooks.transformInclude?.(id)) {
           return null

src/types.ts

@@ -5,12 +5,10 @@ export interface UnpluginHooks {
   transform?: (code: string, id: string) => string | { code: string; map: any; };
 }
 
-export interface UnpluginOptions<UserOptions, ResolvedContext = UserOptions> {
+export interface UnpluginOptions<UserOptions> {
   name: string;
   enforce?: 'post' | 'pre' | undefined;
-  setup(options?: UserOptions): ResolvedContext;
-  hooks(options: ResolvedContext): UnpluginHooks;
-  rollup?: Partial<RollupPlugin>;
+  setup(options?: UserOptions): UnpluginHooks;
 }
 
 export interface UnpluginInstance<UserOptions> {

src/utils.ts

@@ -1,9 +1,8 @@
 import { existsSync, mkdirSync } from 'fs'
-import { dirname } from 'path'
-import { join } from 'path/posix'
+import { dirname, join, resolve } from 'path'
 
 export function getPackageRoot () {
-  return dirname(require.resolve('unplugin/package.json'))
+  return resolve(dirname(__dirname))
 }
 
 export function getLoaderPath (name: string) {

src/webpack.ts

@@ -2,44 +2,41 @@ import fs from 'fs'
 import { UnpluginInstance, UnpluginOptions } from './types'
 import { getLoaderPath } from './utils'
 
-export function getWebpackPlugin<UserOptions = {}, ResolvedContext = UserOptions> (
-  options: UnpluginOptions<UserOptions, ResolvedContext>
+export function getWebpackPlugin<UserOptions = {}> (
+  options: UnpluginOptions<UserOptions>
 ): UnpluginInstance<UserOptions>['webpack'] {
   return class WebpackPlugin {
     // eslint-disable-next-line no-useless-constructor
     constructor (public userOptions?: UserOptions) {}
 
     apply (compiler: any) {
-      const context = options.setup(this.userOptions)
-      const hooks = options.hooks(context)
+      const hooks = options.setup(this.userOptions)
 
       if (!compiler.$unplugin) {
         compiler.$unplugin = {}
       }
-      compiler.$unplugin[options.name] = {
-        context,
-        hooks
-      }
+      compiler.$unplugin[options.name] = hooks
 
       if (hooks.transform) {
         const loaderPath = getLoaderPath(options.name)
 
-        fs.writeFileSync(loaderPath, `module.exports = async function(source) {
-          if (!this._compiler || !this._compiler.$unplugin) return source
-          
-          const plugin = this._compiler.$unplugin['${options.name}']
+        fs.writeFileSync(loaderPath, `
+module.exports = async function(source) {
+  if (!this._compiler || !this._compiler.$unplugin) return source
+  
+  const plugin = this._compiler.$unplugin['${options.name}']
 
-          if (!plugin) return source
+  if (!plugin) return source
 
-          const res = await plugin.hooks.transform(source, this.resource)
+  const res = await plugin.transform(source, this.resource)
 
-          if (typeof res !== 'string') {
-            this.callback(null, res.code, res.map)
-          }
-          else {
-            this.callback(null, res)
-          }
-        }
+  if (typeof res !== 'string') {
+    this.callback(null, res.code, res.map)
+  }
+  else {
+    this.callback(null, res)
+  }
+}
         `, 'utf-8')
 
         compiler.options.module.rules.push({