payload 3.0.0-alpha.5 → 3.0.0-alpha.51

package/dist/bin/register/read-default-tsconfig.js

@@ -0,0 +1,92 @@
+import { resolve } from 'path';
+import ts from 'typescript';
+function toTsTarget(target) {
+    switch(target){
+        case ts.ScriptTarget.ES3:
+            return 'es3';
+        case ts.ScriptTarget.ES5:
+            return 'es5';
+        case ts.ScriptTarget.ES2015:
+            return 'es2015';
+        case ts.ScriptTarget.ES2016:
+            return 'es2016';
+        case ts.ScriptTarget.ES2017:
+            return 'es2017';
+        case ts.ScriptTarget.ES2018:
+            return 'es2018';
+        case ts.ScriptTarget.ES2019:
+            return 'es2019';
+        case ts.ScriptTarget.ES2020:
+            return 'es2020';
+        case ts.ScriptTarget.ES2021:
+            return 'es2021';
+        case ts.ScriptTarget.ES2022:
+        case ts.ScriptTarget.ESNext:
+        case ts.ScriptTarget.Latest:
+            return 'es2022';
+        case ts.ScriptTarget.JSON:
+            return 'es5';
+    }
+}
+function toModule(moduleKind) {
+    switch(moduleKind){
+        case ts.ModuleKind.CommonJS:
+            return 'commonjs';
+        case ts.ModuleKind.UMD:
+            return 'umd';
+        case ts.ModuleKind.AMD:
+            return 'amd';
+        case ts.ModuleKind.ES2015:
+        case ts.ModuleKind.ES2020:
+        case ts.ModuleKind.ES2022:
+        case ts.ModuleKind.ESNext:
+        case ts.ModuleKind.Node16:
+        case ts.ModuleKind.NodeNext:
+        case ts.ModuleKind.None:
+            return 'es6';
+        case ts.ModuleKind.System:
+            throw new TypeError('Do not support system kind module');
+    }
+}
+/**
+ * The default value for useDefineForClassFields depends on the emit target
+ * @see https://www.typescriptlang.org/tsconfig#useDefineForClassFields
+ */ function getUseDefineForClassFields(compilerOptions, target) {
+    return compilerOptions.useDefineForClassFields ?? target >= ts.ScriptTarget.ES2022;
+}
+export function tsCompilerOptionsToSwcConfig(options, filename) {
+    const isJsx = filename.endsWith('.tsx') || filename.endsWith('.jsx') || Boolean(options.jsx);
+    const target = options.target ?? ts.ScriptTarget.ES2018;
+    return {
+        baseUrl: options.baseUrl ? resolve(options.baseUrl) : undefined,
+        dynamicImport: true,
+        emitDecoratorMetadata: options.emitDecoratorMetadata ?? false,
+        esModuleInterop: options.esModuleInterop ?? false,
+        experimentalDecorators: options.experimentalDecorators ?? false,
+        externalHelpers: Boolean(options.importHelpers),
+        ignoreDynamic: Boolean(process.env.SWC_NODE_IGNORE_DYNAMIC),
+        jsx: isJsx,
+        keepClassNames: true,
+        module: toModule(options.module ?? ts.ModuleKind.ES2015),
+        paths: Object.fromEntries(Object.entries(options.paths ?? {}).map(([aliasKey, aliasPaths])=>[
+                aliasKey,
+                (aliasPaths ?? []).map((path)=>resolve(options.baseUrl ?? './', path))
+            ])),
+        react: options.jsxFactory ?? options.jsxFragmentFactory ?? options.jsx ?? options.jsxImportSource ? {
+            importSource: options.jsxImportSource ?? 'react',
+            pragma: options.jsxFactory,
+            pragmaFrag: options.jsxFragmentFactory,
+            runtime: (options.jsx ?? 0) >= ts.JsxEmit.ReactJSX ? 'automatic' : 'classic',
+            useBuiltins: true
+        } : undefined,
+        sourcemap: options.sourceMap && options.inlineSourceMap ? 'inline' : Boolean(options.sourceMap),
+        swc: {
+            inputSourceMap: options.inlineSourceMap,
+            sourceRoot: options.sourceRoot
+        },
+        target: toTsTarget(target),
+        useDefineForClassFields: getUseDefineForClassFields(options, target)
+    };
+}
+
+//# sourceMappingURL=read-default-tsconfig.js.map

package/dist/bin/register/read-default-tsconfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/bin/register/read-default-tsconfig.ts"],"sourcesContent":["import type { Options } from '@swc-node/core'\n\nimport { resolve } from 'path'\nimport ts from 'typescript'\n\nfunction toTsTarget(target: ts.ScriptTarget): Options['target'] {\n  switch (target) {\n    case ts.ScriptTarget.ES3:\n      return 'es3'\n    case ts.ScriptTarget.ES5:\n      return 'es5'\n    case ts.ScriptTarget.ES2015:\n      return 'es2015'\n    case ts.ScriptTarget.ES2016:\n      return 'es2016'\n    case ts.ScriptTarget.ES2017:\n      return 'es2017'\n    case ts.ScriptTarget.ES2018:\n      return 'es2018'\n    case ts.ScriptTarget.ES2019:\n      return 'es2019'\n    case ts.ScriptTarget.ES2020:\n      return 'es2020'\n    case ts.ScriptTarget.ES2021:\n      return 'es2021'\n    case ts.ScriptTarget.ES2022:\n    case ts.ScriptTarget.ESNext:\n    case ts.ScriptTarget.Latest:\n      return 'es2022'\n    case ts.ScriptTarget.JSON:\n      return 'es5'\n  }\n}\n\nfunction toModule(moduleKind: ts.ModuleKind) {\n  switch (moduleKind) {\n    case ts.ModuleKind.CommonJS:\n      return 'commonjs'\n    case ts.ModuleKind.UMD:\n      return 'umd'\n    case ts.ModuleKind.AMD:\n      return 'amd'\n    case ts.ModuleKind.ES2015:\n    case ts.ModuleKind.ES2020:\n    case ts.ModuleKind.ES2022:\n    case ts.ModuleKind.ESNext:\n    case ts.ModuleKind.Node16:\n    case ts.ModuleKind.NodeNext:\n    case ts.ModuleKind.None:\n      return 'es6'\n    case ts.ModuleKind.System:\n      throw new TypeError('Do not support system kind module')\n  }\n}\n\n/**\n * The default value for useDefineForClassFields depends on the emit target\n * @see https://www.typescriptlang.org/tsconfig#useDefineForClassFields\n */\nfunction getUseDefineForClassFields(\n  compilerOptions: ts.CompilerOptions,\n  target: ts.ScriptTarget,\n): boolean {\n  return compilerOptions.useDefineForClassFields ?? target >= ts.ScriptTarget.ES2022\n}\n\nexport function tsCompilerOptionsToSwcConfig(\n  options: ts.CompilerOptions,\n  filename: string,\n): Options {\n  const isJsx = filename.endsWith('.tsx') || filename.endsWith('.jsx') || Boolean(options.jsx)\n  const target = options.target ?? ts.ScriptTarget.ES2018\n  return {\n    baseUrl: options.baseUrl ? resolve(options.baseUrl) : undefined,\n    dynamicImport: true,\n    emitDecoratorMetadata: options.emitDecoratorMetadata ?? false,\n    esModuleInterop: options.esModuleInterop ?? false,\n    experimentalDecorators: options.experimentalDecorators ?? false,\n    externalHelpers: Boolean(options.importHelpers),\n    ignoreDynamic: Boolean(process.env.SWC_NODE_IGNORE_DYNAMIC),\n    jsx: isJsx,\n    keepClassNames: true,\n    module: toModule(options.module ?? ts.ModuleKind.ES2015),\n    paths: Object.fromEntries(\n      Object.entries(options.paths ?? {}).map(([aliasKey, aliasPaths]) => [\n        aliasKey,\n        (aliasPaths ?? []).map((path) => resolve(options.baseUrl ?? './', path)),\n      ]),\n    ) as Options['paths'],\n    react:\n      options.jsxFactory ?? options.jsxFragmentFactory ?? options.jsx ?? options.jsxImportSource\n        ? {\n            importSource: options.jsxImportSource ?? 'react',\n            pragma: options.jsxFactory,\n            pragmaFrag: options.jsxFragmentFactory,\n            runtime: (options.jsx ?? 0) >= ts.JsxEmit.ReactJSX ? 'automatic' : 'classic',\n            useBuiltins: true,\n          }\n        : undefined,\n    sourcemap: options.sourceMap && options.inlineSourceMap ? 'inline' : Boolean(options.sourceMap),\n    swc: {\n      inputSourceMap: options.inlineSourceMap,\n      sourceRoot: options.sourceRoot,\n    },\n    target: toTsTarget(target),\n    useDefineForClassFields: getUseDefineForClassFields(options, target),\n  }\n}\n"],"names":["resolve","ts","toTsTarget","target","ScriptTarget","ES3","ES5","ES2015","ES2016","ES2017","ES2018","ES2019","ES2020","ES2021","ES2022","ESNext","Latest","JSON","toModule","moduleKind","ModuleKind","CommonJS","UMD","AMD","Node16","NodeNext","None","System","TypeError","getUseDefineForClassFields","compilerOptions","useDefineForClassFields","tsCompilerOptionsToSwcConfig","options","filename","isJsx","endsWith","Boolean","jsx","baseUrl","undefined","dynamicImport","emitDecoratorMetadata","esModuleInterop","experimentalDecorators","externalHelpers","importHelpers","ignoreDynamic","process","env","SWC_NODE_IGNORE_DYNAMIC","keepClassNames","module","paths","Object","fromEntries","entries","map","aliasKey","aliasPaths","path","react","jsxFactory","jsxFragmentFactory","jsxImportSource","importSource","pragma","pragmaFrag","runtime","JsxEmit","ReactJSX","useBuiltins","sourcemap","sourceMap","inlineSourceMap","swc","inputSourceMap","sourceRoot"],"mappings":"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"}

package/dist/bin/register/register.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+export declare function compile(sourcecode: string, filename: string, options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean;
+}): string;
+export declare function compile(sourcecode: string, filename: string, options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean;
+}, async: false): string;
+export declare function compile(sourcecode: string, filename: string, options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean;
+}, async: true): Promise<string>;
+export declare function compile(sourcecode: string, filename: string, options: ts.CompilerOptions & {
+    fallbackToTs?: (filename: string) => boolean;
+}, async: boolean): Promise<string> | string;
+export declare function register(options?: Partial<ts.CompilerOptions>, hookOpts?: {}): () => void;
+//# sourceMappingURL=register.d.ts.map

package/dist/bin/register/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/bin/register/register.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAA;AAyBhC,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,EAAE,CAAC,eAAe,GAAG;IAAE,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GAC7E,MAAM,CAAA;AAET,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,EAAE,CAAC,eAAe,GAAG;IAAE,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,EAC9E,KAAK,EAAE,KAAK,GACX,MAAM,CAAA;AAET,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,EAAE,CAAC,eAAe,GAAG;IAAE,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,EAC9E,KAAK,EAAE,IAAI,GACV,OAAO,CAAC,MAAM,CAAC,CAAA;AAElB,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,EAAE,CAAC,eAAe,GAAG;IAAE,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,EAC9E,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;AAwD3B,wBAAgB,QAAQ,CAAC,OAAO,GAAE,OAAO,CAAC,EAAE,CAAC,eAAe,CAAM,EAAE,QAAQ,KAAK,cAUhF"}

package/dist/bin/register/register.js

@@ -0,0 +1,92 @@
+import { transform, transformSync } from '@swc-node/core';
+import { SourcemapMap, installSourceMapSupport } from '@swc-node/sourcemap-support';
+import { getTsconfig } from 'get-tsconfig';
+import { platform } from 'os';
+import { resolve } from 'path';
+import { addHook } from 'pirates';
+import * as ts from 'typescript';
+import { tsCompilerOptionsToSwcConfig } from './read-default-tsconfig.js';
+const DEFAULT_EXTENSIONS = [
+    '.js',
+    '.jsx',
+    '.es6',
+    '.es',
+    '.mjs',
+    '.ts',
+    '.tsx'
+];
+const PLATFORM = platform();
+const injectInlineSourceMap = ({ code, filename, map })=>{
+    if (map) {
+        SourcemapMap.set(filename, map);
+        const base64Map = Buffer.from(map, 'utf8').toString('base64');
+        const sourceMapContent = `//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64Map}`;
+        return `${code}\n${sourceMapContent}`;
+    }
+    return code;
+};
+export function compile(sourcecode, filename, options, async = false) {
+    if (filename.endsWith('.d.ts')) {
+        return '';
+    }
+    if (options.files && options.files.length) {
+        if (PLATFORM === 'win32' && options.files.every((file)=>filename !== resolve(process.cwd(), file))) {
+            return sourcecode;
+        }
+        if (PLATFORM !== 'win32' && options.files.every((file)=>!filename.endsWith(file))) {
+            return sourcecode;
+        }
+    }
+    if (options && typeof options.fallbackToTs === 'function' && options.fallbackToTs(filename)) {
+        delete options.fallbackToTs;
+        const { outputText, sourceMapText } = ts.transpileModule(sourcecode, {
+            compilerOptions: options,
+            fileName: filename
+        });
+        return injectInlineSourceMap({
+            code: outputText,
+            filename,
+            map: sourceMapText
+        });
+    }
+    let swcRegisterConfig;
+    if (process.env.SWCRC) {
+        // when SWCRC environment variable is set to true it will use swcrc file
+        swcRegisterConfig = {
+            swc: {
+                swcrc: true
+            }
+        };
+    } else {
+        swcRegisterConfig = tsCompilerOptionsToSwcConfig(options, filename);
+    }
+    if (async) {
+        return transform(sourcecode, filename, swcRegisterConfig).then(({ code, map })=>{
+            return injectInlineSourceMap({
+                code,
+                filename,
+                map
+            });
+        });
+    } else {
+        const { code, map } = transformSync(sourcecode, filename, swcRegisterConfig);
+        return injectInlineSourceMap({
+            code,
+            filename,
+            map
+        });
+    }
+}
+export function register(options = {}, hookOpts = {}) {
+    const locatedConfig = getTsconfig();
+    const tsconfig = locatedConfig.config.compilerOptions;
+    options = tsconfig;
+    // options.module = ts.ModuleKind.CommonJS
+    installSourceMapSupport();
+    return addHook((code, filename)=>compile(code, filename, options), {
+        exts: DEFAULT_EXTENSIONS,
+        ...hookOpts
+    });
+}
+
+//# sourceMappingURL=register.js.map

package/dist/bin/register/register.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/bin/register/register.ts"],"sourcesContent":["import type { Options } from '@swc-node/core'\n\nimport { transform, transformSync } from '@swc-node/core'\nimport { SourcemapMap, installSourceMapSupport } from '@swc-node/sourcemap-support'\nimport { getTsconfig } from 'get-tsconfig'\nimport { platform } from 'os'\nimport { resolve } from 'path'\nimport { addHook } from 'pirates'\nimport * as ts from 'typescript'\n\nimport { tsCompilerOptionsToSwcConfig } from './read-default-tsconfig.js'\n\nconst DEFAULT_EXTENSIONS = ['.js', '.jsx', '.es6', '.es', '.mjs', '.ts', '.tsx']\nconst PLATFORM = platform()\n\nconst injectInlineSourceMap = ({\n  code,\n  filename,\n  map,\n}: {\n  code: string\n  filename: string\n  map: string | undefined\n}): string => {\n  if (map) {\n    SourcemapMap.set(filename, map)\n    const base64Map = Buffer.from(map, 'utf8').toString('base64')\n    const sourceMapContent = `//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64Map}`\n    return `${code}\\n${sourceMapContent}`\n  }\n  return code\n}\n\nexport function compile(\n  sourcecode: string,\n  filename: string,\n  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },\n): string\n\nexport function compile(\n  sourcecode: string,\n  filename: string,\n  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },\n  async: false,\n): string\n\nexport function compile(\n  sourcecode: string,\n  filename: string,\n  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },\n  async: true,\n): Promise<string>\n\nexport function compile(\n  sourcecode: string,\n  filename: string,\n  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },\n  async: boolean,\n): Promise<string> | string\n\nexport function compile(\n  sourcecode: string,\n  filename: string,\n  options: ts.CompilerOptions & { fallbackToTs?: (filename: string) => boolean },\n  async = false,\n) {\n  if (filename.endsWith('.d.ts')) {\n    return ''\n  }\n  if (options.files && (options.files as string[]).length) {\n    if (\n      PLATFORM === 'win32' &&\n      (options.files as string[]).every((file) => filename !== resolve(process.cwd(), file))\n    ) {\n      return sourcecode\n    }\n    if (\n      PLATFORM !== 'win32' &&\n      (options.files as string[]).every((file) => !filename.endsWith(file))\n    ) {\n      return sourcecode\n    }\n  }\n  if (options && typeof options.fallbackToTs === 'function' && options.fallbackToTs(filename)) {\n    delete options.fallbackToTs\n    const { outputText, sourceMapText } = ts.transpileModule(sourcecode, {\n      compilerOptions: options,\n      fileName: filename,\n    })\n    return injectInlineSourceMap({ code: outputText, filename, map: sourceMapText })\n  }\n\n  let swcRegisterConfig: Options\n  if (process.env.SWCRC) {\n    // when SWCRC environment variable is set to true it will use swcrc file\n    swcRegisterConfig = {\n      swc: {\n        swcrc: true,\n      },\n    }\n  } else {\n    swcRegisterConfig = tsCompilerOptionsToSwcConfig(options, filename)\n  }\n\n  if (async) {\n    return transform(sourcecode, filename, swcRegisterConfig).then(({ code, map }) => {\n      return injectInlineSourceMap({ code, filename, map })\n    })\n  } else {\n    const { code, map } = transformSync(sourcecode, filename, swcRegisterConfig)\n    return injectInlineSourceMap({ code, filename, map })\n  }\n}\n\nexport function register(options: Partial<ts.CompilerOptions> = {}, hookOpts = {}) {\n  const locatedConfig = getTsconfig()\n  const tsconfig = locatedConfig.config.compilerOptions as unknown as ts.CompilerOptions\n  options = tsconfig\n  // options.module = ts.ModuleKind.CommonJS\n  installSourceMapSupport()\n  return addHook((code, filename) => compile(code, filename, options), {\n    exts: DEFAULT_EXTENSIONS,\n    ...hookOpts,\n  })\n}\n"],"names":["transform","transformSync","SourcemapMap","installSourceMapSupport","getTsconfig","platform","resolve","addHook","ts","tsCompilerOptionsToSwcConfig","DEFAULT_EXTENSIONS","PLATFORM","injectInlineSourceMap","code","filename","map","set","base64Map","Buffer","from","toString","sourceMapContent","compile","sourcecode","options","async","endsWith","files","length","every","file","process","cwd","fallbackToTs","outputText","sourceMapText","transpileModule","compilerOptions","fileName","swcRegisterConfig","env","SWCRC","swc","swcrc","then","register","hookOpts","locatedConfig","tsconfig","config","exts"],"mappings":"AAEA,SAASA,SAAS,EAAEC,aAAa,QAAQ,iBAAgB;AACzD,SAASC,YAAY,EAAEC,uBAAuB,QAAQ,8BAA6B;AACnF,SAASC,WAAW,QAAQ,eAAc;AAC1C,SAASC,QAAQ,QAAQ,KAAI;AAC7B,SAASC,OAAO,QAAQ,OAAM;AAC9B,SAASC,OAAO,QAAQ,UAAS;AACjC,YAAYC,QAAQ,aAAY;AAEhC,SAASC,4BAA4B,QAAQ,6BAA4B;AAEzE,MAAMC,qBAAqB;IAAC;IAAO;IAAQ;IAAQ;IAAO;IAAQ;IAAO;CAAO;AAChF,MAAMC,WAAWN;AAEjB,MAAMO,wBAAwB,CAAC,EAC7BC,IAAI,EACJC,QAAQ,EACRC,GAAG,EAKJ;IACC,IAAIA,KAAK;QACPb,aAAac,GAAG,CAACF,UAAUC;QAC3B,MAAME,YAAYC,OAAOC,IAAI,CAACJ,KAAK,QAAQK,QAAQ,CAAC;QACpD,MAAMC,mBAAmB,CAAC,gEAAgE,EAAEJ,UAAU,CAAC;QACvG,OAAO,CAAC,EAAEJ,KAAK,EAAE,EAAEQ,iBAAiB,CAAC;IACvC;IACA,OAAOR;AACT;AA6BA,OAAO,SAASS,QACdC,UAAkB,EAClBT,QAAgB,EAChBU,OAA8E,EAC9EC,QAAQ,KAAK;IAEb,IAAIX,SAASY,QAAQ,CAAC,UAAU;QAC9B,OAAO;IACT;IACA,IAAIF,QAAQG,KAAK,IAAI,AAACH,QAAQG,KAAK,CAAcC,MAAM,EAAE;QACvD,IACEjB,aAAa,WACb,AAACa,QAAQG,KAAK,CAAcE,KAAK,CAAC,CAACC,OAAShB,aAAaR,QAAQyB,QAAQC,GAAG,IAAIF,QAChF;YACA,OAAOP;QACT;QACA,IACEZ,aAAa,WACb,AAACa,QAAQG,KAAK,CAAcE,KAAK,CAAC,CAACC,OAAS,CAAChB,SAASY,QAAQ,CAACI,QAC/D;YACA,OAAOP;QACT;IACF;IACA,IAAIC,WAAW,OAAOA,QAAQS,YAAY,KAAK,cAAcT,QAAQS,YAAY,CAACnB,WAAW;QAC3F,OAAOU,QAAQS,YAAY;QAC3B,MAAM,EAAEC,UAAU,EAAEC,aAAa,EAAE,GAAG3B,GAAG4B,eAAe,CAACb,YAAY;YACnEc,iBAAiBb;YACjBc,UAAUxB;QACZ;QACA,OAAOF,sBAAsB;YAAEC,MAAMqB;YAAYpB;YAAUC,KAAKoB;QAAc;IAChF;IAEA,IAAII;IACJ,IAAIR,QAAQS,GAAG,CAACC,KAAK,EAAE;QACrB,wEAAwE;QACxEF,oBAAoB;YAClBG,KAAK;gBACHC,OAAO;YACT;QACF;IACF,OAAO;QACLJ,oBAAoB9B,6BAA6Be,SAASV;IAC5D;IAEA,IAAIW,OAAO;QACT,OAAOzB,UAAUuB,YAAYT,UAAUyB,mBAAmBK,IAAI,CAAC,CAAC,EAAE/B,IAAI,EAAEE,GAAG,EAAE;YAC3E,OAAOH,sBAAsB;gBAAEC;gBAAMC;gBAAUC;YAAI;QACrD;IACF,OAAO;QACL,MAAM,EAAEF,IAAI,EAAEE,GAAG,EAAE,GAAGd,cAAcsB,YAAYT,UAAUyB;QAC1D,OAAO3B,sBAAsB;YAAEC;YAAMC;YAAUC;QAAI;IACrD;AACF;AAEA,OAAO,SAAS8B,SAASrB,UAAuC,CAAC,CAAC,EAAEsB,WAAW,CAAC,CAAC;IAC/E,MAAMC,gBAAgB3C;IACtB,MAAM4C,WAAWD,cAAcE,MAAM,CAACZ,eAAe;IACrDb,UAAUwB;IACV,0CAA0C;IAC1C7C;IACA,OAAOI,QAAQ,CAACM,MAAMC,WAAaQ,QAAQT,MAAMC,UAAUU,UAAU;QACnE0B,MAAMxC;QACN,GAAGoC,QAAQ;IACb;AACF"}

package/dist/collections/config/build.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionConfig } from './types';
+import type { CollectionConfig } from './types.js';
 declare const buildCollection: (collection: CollectionConfig) => CollectionConfig;
 export default buildCollection;
 //# sourceMappingURL=build.d.ts.map

package/dist/collections/config/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/collections/config/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,QAAA,MAAM,eAAe,eAAgB,gBAAgB,KAAG,gBAA8B,CAAA;AAEtF,eAAe,eAAe,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/collections/config/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,QAAA,MAAM,eAAe,eAAgB,gBAAgB,KAAG,gBAA8B,CAAA;AAEtF,eAAe,eAAe,CAAA"}

package/dist/collections/config/build.js

@@ -1,14 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
 const buildCollection = (collection)=>collection;
-const _default = buildCollection;
+export default buildCollection;
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb2xsZWN0aW9ucy9jb25maWcvYnVpbGQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDb2xsZWN0aW9uQ29uZmlnIH0gZnJvbSAnLi90eXBlcydcblxuY29uc3QgYnVpbGRDb2xsZWN0aW9uID0gKGNvbGxlY3Rpb246IENvbGxlY3Rpb25Db25maWcpOiBDb2xsZWN0aW9uQ29uZmlnID0+IGNvbGxlY3Rpb25cblxuZXhwb3J0IGRlZmF1bHQgYnVpbGRDb2xsZWN0aW9uXG4iXSwibmFtZXMiOlsiYnVpbGRDb2xsZWN0aW9uIiwiY29sbGVjdGlvbiJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFJQTs7O2VBQUE7OztBQUZBLE1BQU1BLGtCQUFrQixDQUFDQyxhQUFtREE7TUFFNUUsV0FBZUQifQ==
+//# sourceMappingURL=build.js.map

package/dist/collections/config/build.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/collections/config/build.ts"],"sourcesContent":["import type { CollectionConfig } from './types.js'\n\nconst buildCollection = (collection: CollectionConfig): CollectionConfig => collection\n\nexport default buildCollection\n"],"names":["buildCollection","collection"],"mappings":"AAEA,MAAMA,kBAAkB,CAACC,aAAmDA;AAE5E,eAAeD,gBAAe"}

package/dist/collections/config/client.d.ts

@@ -0,0 +1,311 @@
+import type { LivePreviewConfig, ServerOnlyLivePreviewProperties } from '../../config/types.js';
+export type ServerOnlyCollectionProperties = keyof Pick<SanitizedCollectionConfig, 'access' | 'endpoints' | 'hooks'>;
+export type ServerOnlyCollectionAdminProperties = keyof Pick<SanitizedCollectionConfig['admin'], 'components' | 'hidden' | 'preview'>;
+export type ClientCollectionConfig = Omit<SanitizedCollectionConfig, 'admin' | 'fields' | ServerOnlyCollectionProperties> & {
+    admin: Omit<SanitizedCollectionConfig['admin'], 'fields' | 'livePreview' | ServerOnlyCollectionAdminProperties> & {
+        livePreview?: Omit<LivePreviewConfig, ServerOnlyLivePreviewProperties>;
+    };
+    fields: ClientFieldConfig[];
+};
+import type { ClientFieldConfig } from '../../fields/config/client.js';
+import type { SanitizedCollectionConfig } from './types.js';
+export declare const createClientCollectionConfig: (collection: SanitizedCollectionConfig) => {
+    auth: import("packages/payload/src/auth/types.js").Auth;
+    endpoints: false | import("../../config/types.js").Endpoint[];
+    fields: import("packages/payload/src/exports/types.js").Field[];
+    upload: import("packages/payload/src/uploads/types.js").SanitizedUploadConfig;
+    versions: import("packages/payload/src/versions/types.js").SanitizedCollectionVersions;
+    admin: {
+        components: {
+            AfterList: import("react").ComponentType<any>[];
+            AfterListTable: import("react").ComponentType<any>[];
+            BeforeList: import("react").ComponentType<any>[];
+            BeforeListTable: import("react").ComponentType<any>[];
+            edit: {
+                PreviewButton: import("packages/payload/src/admin/types.js").CustomPreviewButton;
+                PublishButton: import("packages/payload/src/admin/types.js").CustomPublishButton;
+                SaveButton: import("packages/payload/src/admin/types.js").CustomSaveButton;
+                SaveDraftButton: import("packages/payload/src/admin/types.js").CustomSaveDraftButton;
+            };
+            views: {
+                Edit: import("../../config/types.js").EditViewComponent | {
+                    API: import("../../config/types.js").EditViewComponent | {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                    Default: import("../../config/types.js").EditViewComponent | {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                    LivePreview: import("../../config/types.js").EditViewComponent | {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                    Version: import("../../config/types.js").EditViewComponent | {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                    Versions: import("../../config/types.js").EditViewComponent | {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                } | {
+                    [x: string]: {
+                        Tab: import("packages/payload/src/admin/types.js").DocumentTabComponent | {
+                            Pill: import("react").ComponentType<{}>;
+                            condition: import("packages/payload/src/admin/types.js").DocumentTabCondition;
+                            href: string | ((args: {
+                                apiURL: string;
+                                collection: SanitizedCollectionConfig;
+                                global: import("packages/payload/src/exports/types.js").SanitizedGlobalConfig;
+                                id?: string;
+                                routes: {
+                                    admin: string;
+                                    api: string;
+                                    graphQL: string;
+                                    graphQLPlayground: string;
+                                };
+                            }) => string);
+                            isActive: boolean | ((args: {
+                                href: string;
+                            }) => boolean);
+                            label: string | ((args: {
+                                t: (key: string) => string;
+                            }) => string);
+                            newTab: boolean;
+                        };
+                        path: string;
+                    } | {
+                        Component: import("../../config/types.js").EditViewComponent;
+                        path: string;
+                    } | {
+                        actions: import("react").ComponentType<any>[];
+                    };
+                };
+                List: import("react").ComponentType<any> | {
+                    Component: import("react").ComponentType<any>;
+                    actions: import("react").ComponentType<any>[];
+                };
+            };
+        };
+        defaultColumns: string[];
+        description: string | import("../../config/types.js").EntityDescriptionComponent | import("../../config/types.js").EntityDescriptionFunction | {
+            [x: string]: string;
+        };
+        disableDuplicate: boolean;
+        enableRichTextLink: boolean;
+        enableRichTextRelationship: boolean;
+        group: string | {
+            [x: string]: string;
+        };
+        hidden: boolean | ((args: {
+            user: import("packages/payload/src/auth/types.js").ClientUser;
+        }) => boolean);
+        hideAPIURL: boolean;
+        listSearchableFields: string[];
+        livePreview: {
+            breakpoints: {
+                height: string | number;
+                label: string;
+                name: string;
+                width: string | number;
+            }[];
+            url: string | ((args: {
+                data: Record<string, any>;
+                documentInfo: any;
+                locale: import("../../config/types.js").Locale;
+            }) => string | Promise<string>);
+        };
+        pagination: {
+            defaultLimit: number;
+            limits: number[];
+        };
+        preview: import("../../config/types.js").GeneratePreviewURL;
+        useAsTitle: string;
+    };
+    custom: {
+        [x: string]: any;
+    };
+    graphQL: false | {
+        pluralName: string;
+        singularName: string;
+    };
+    hooks: {
+        afterChange: import("./types.js").AfterChangeHook<any>[];
+        afterDelete: import("./types.js").AfterDeleteHook<any>[];
+        afterError: import("./types.js").AfterErrorHook;
+        afterForgotPassword: import("./types.js").AfterForgotPasswordHook[];
+        afterLogin: import("./types.js").AfterLoginHook<any>[];
+        afterLogout: import("./types.js").AfterLogoutHook<any>[];
+        afterMe: import("./types.js").AfterMeHook<any>[];
+        afterOperation: import("./types.js").AfterOperationHook<any>[];
+        afterRead: import("./types.js").AfterReadHook<any>[];
+        afterRefresh: import("./types.js").AfterRefreshHook<any>[];
+        beforeChange: import("./types.js").BeforeChangeHook<any>[];
+        beforeDelete: import("./types.js").BeforeDeleteHook[];
+        beforeLogin: import("./types.js").BeforeLoginHook<any>[];
+        beforeOperation: import("./types.js").BeforeOperationHook[];
+        beforeRead: import("./types.js").BeforeReadHook<any>[];
+        beforeValidate: import("./types.js").BeforeValidateHook<any>[];
+    };
+    typescript: {
+        interface: string;
+    };
+    access: {
+        admin: (args?: any) => boolean | Promise<boolean>;
+        create: import("../../config/types.js").Access;
+        delete: import("../../config/types.js").Access;
+        read: import("../../config/types.js").Access;
+        readVersions: import("../../config/types.js").Access;
+        unlock: import("../../config/types.js").Access;
+        update: import("../../config/types.js").Access;
+    };
+    defaultSort: string;
+    labels: {
+        plural: string | {
+            [x: string]: string;
+        };
+        singular: string | {
+            [x: string]: string;
+        };
+    };
+    slug: string;
+    timestamps: boolean;
+};
+export declare const createClientCollectionConfigs: (collections: SanitizedCollectionConfig[]) => ClientCollectionConfig[];
+//# sourceMappingURL=client.d.ts.map

package/dist/collections/config/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/collections/config/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAA;AAE/F,MAAM,MAAM,8BAA8B,GAAG,MAAM,IAAI,CACrD,yBAAyB,EACzB,QAAQ,GAAG,WAAW,GAAG,OAAO,CACjC,CAAA;AAED,MAAM,MAAM,mCAAmC,GAAG,MAAM,IAAI,CAC1D,yBAAyB,CAAC,OAAO,CAAC,EAClC,YAAY,GAAG,QAAQ,GAAG,SAAS,CACpC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,yBAAyB,EACzB,OAAO,GAAG,QAAQ,GAAG,8BAA8B,CACpD,GAAG;IACF,KAAK,EAAE,IAAI,CACT,yBAAyB,CAAC,OAAO,CAAC,EAClC,QAAQ,GAAG,aAAa,GAAG,mCAAmC,CAC/D,GAAG;QACF,WAAW,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,+BAA+B,CAAC,CAAA;KACvE,CAAA;IACD,MAAM,EAAE,iBAAiB,EAAE,CAAA;CAC5B,CAAA;AAED,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAI3D,eAAO,MAAM,4BAA4B,eAAgB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDjF,CAAA;AAED,eAAO,MAAM,6BAA6B,gBAC3B,yBAAyB,EAAE,KACvC,sBAAsB,EACkD,CAAA"}

package/dist/collections/config/client.js

@@ -0,0 +1,57 @@
+import { createClientFieldConfigs } from '../../fields/config/client.js';
+export const createClientCollectionConfig = (collection)=>{
+    const sanitized = {
+        ...collection
+    };
+    sanitized.fields = createClientFieldConfigs(sanitized.fields);
+    const serverOnlyCollectionProperties = [
+        'hooks',
+        'access',
+        'endpoints'
+    ];
+    serverOnlyCollectionProperties.forEach((key)=>{
+        if (key in sanitized) {
+            delete sanitized[key];
+        }
+    });
+    if ('upload' in sanitized && typeof sanitized.upload === 'object') {
+        sanitized.upload = {
+            ...sanitized.upload
+        };
+        delete sanitized.upload.handlers;
+        delete sanitized.upload.adminThumbnail;
+    }
+    if ('auth' in sanitized && typeof sanitized.auth === 'object') {
+        sanitized.auth = {
+            ...sanitized.auth
+        };
+        delete sanitized.auth.strategies;
+        delete sanitized.auth.forgotPassword;
+        delete sanitized.auth.verify;
+    }
+    if ('admin' in sanitized) {
+        sanitized.admin = {
+            ...sanitized.admin
+        };
+        const serverOnlyCollectionAdminProperties = [
+            'components',
+            'hidden',
+            'preview'
+        ];
+        serverOnlyCollectionAdminProperties.forEach((key)=>{
+            if (key in sanitized.admin) {
+                delete sanitized.admin[key];
+            }
+        });
+        if ('livePreview' in sanitized.admin) {
+            sanitized.admin.livePreview = {
+                ...sanitized.admin.livePreview
+            };
+            delete sanitized.admin.livePreview.url;
+        }
+    }
+    return sanitized;
+};
+export const createClientCollectionConfigs = (collections)=>collections.map((collection)=>createClientCollectionConfig(collection));
+
+//# sourceMappingURL=client.js.map