@kubb/core 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Stijn Van Hulle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# Demo

package/dist/ast/index.d.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+
+declare const generateStringTemplate: <TParams = Record<string, string | ts.Node | undefined>>(templateStrings: string | TemplateStringsArray, ...placeholders: (string | ts.Node)[]) => (params?: TParams | undefined) => string | undefined;
+declare const logDemoTemplate: () => Promise<void>;
+
+declare const print: (elements: ts.Node[], fileName?: string) => string;
+
+declare const index_generateStringTemplate: typeof generateStringTemplate;
+declare const index_logDemoTemplate: typeof logDemoTemplate;
+declare const index_print: typeof print;
+declare namespace index {
+  export {
+    index_generateStringTemplate as generateStringTemplate,
+    index_logDemoTemplate as logDemoTemplate,
+    index_print as print,
+  };
+}
+
+export { index as typescript };

package/dist/ast/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var ts = require('typescript');
+var talt = require('talt');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ast/typescript/index.ts
+var typescript_exports = {};
+__export(typescript_exports, {
+  generateStringTemplate: () => generateStringTemplate,
+  logDemoTemplate: () => logDemoTemplate,
+  print: () => print
+});
+var print = (elements, fileName = "print.ts") => {
+  const nodes = ts.factory.createNodeArray(elements);
+  const sourceFile = ts.createSourceFile(fileName, "", ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+  const printer = ts.createPrinter();
+  const outputFile = printer.printList(ts.ListFormat.MultiLine, nodes, sourceFile);
+  return outputFile;
+};
+
+// src/ast/typescript/generate.ts
+var generateStringTemplate = (templateStrings, ...placeholders) => {
+  const compiledFn = talt.template.statement(templateStrings, ...placeholders);
+  return (params) => {
+    if (!params) {
+      return void 0;
+    }
+    const idPlaceholders = {};
+    Object.keys(params).forEach((key) => {
+      idPlaceholders[key] = typeof params[key] ? ts.factory.createStringLiteral(params[key]) : params[key];
+    });
+    const generatedAst = compiledFn(idPlaceholders);
+    return print([generatedAst]);
+  };
+};
+var logDemoTemplate = async () => {
+  const typeNode = talt.template.typeNode("{ readonly test: string }")();
+  talt.template.typeNode`
+    {
+      readonly test: string;
+    }
+  `();
+  console.log(print([typeNode]));
+};
+
+exports.typescript = typescript_exports;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map

package/dist/ast/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ast/typescript/index.ts","../../src/ast/typescript/generate.ts","../../src/ast/typescript/utils/print.ts"],"names":["ts"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACGA,OAAOA,SAAQ;AACf,SAAS,gBAAgB;;;ACJzB,OAAO,QAAQ;AAER,IAAM,QAAQ,CAAC,UAAqB,WAAW,eAAe;AACnE,QAAM,QAAQ,GAAG,QAAQ,gBAAgB,QAAQ;AACjD,QAAM,aAAa,GAAG,iBAAiB,UAAU,IAAI,GAAG,aAAa,QAAQ,MAAM,GAAG,WAAW,EAAE;AAEnG,QAAM,UAAU,GAAG,cAAc;AACjC,QAAM,aAAa,QAAQ,UAAU,GAAG,WAAW,WAAW,OAAO,UAAU;AAE/E,SAAO;AACT;;;ADFO,IAAM,yBAAyB,CACpC,oBACG,iBACA;AACH,QAAM,aAAa,SAAS,UAAU,iBAAiB,GAAG,YAAY;AACtE,SAAO,CAAC,WAAqB;AAC3B,QAAI,CAAC,QAAQ;AACX,aAAO;AAAA,IACT;AACA,UAAM,iBAA0C,CAAC;AAEjD,WAAO,KAAK,MAAM,EAAE,QAAQ,CAAC,QAAQ;AACnC,qBAAe,OAAO,OAAO,OAAO,OAAOA,IAAG,QAAQ,oBAAoB,OAAO,IAAI,IAAI,OAAO;AAAA,IAClG,CAAC;AAED,UAAM,eAAe,WAAW,cAAc;AAE9C,WAAO,MAAM,CAAC,YAAY,CAAC;AAAA,EAC7B;AACF;AAEO,IAAM,kBAAkB,YAAY;AACzC,QAAM,WAAW,SAAS,SAAS,2BAA2B,EAAE;AAGhE,QAAM,qBAAqB,SAAS;AAAA;AAAA;AAAA;AAAA,IAIlC;AAEF,UAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC/B","sourcesContent":["export * from './generate'\nexport * from './utils'\n","/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable no-console */\n\nimport ts from 'typescript'\nimport { template } from 'talt'\n\nimport { print } from './utils/print'\n\nexport const generateStringTemplate = <TParams = Record<string, ts.Node | string | undefined>>(\n  templateStrings: string | TemplateStringsArray,\n  ...placeholders: (string | ts.Node)[]\n) => {\n  const compiledFn = template.statement(templateStrings, ...placeholders)\n  return (params?: TParams) => {\n    if (!params) {\n      return undefined\n    }\n    const idPlaceholders: Record<string, ts.Node> = {}\n\n    Object.keys(params).forEach((key) => {\n      idPlaceholders[key] = typeof params[key] ? ts.factory.createStringLiteral(params[key]) : params[key]\n    })\n\n    const generatedAst = compiledFn(idPlaceholders)\n\n    return print([generatedAst])\n  }\n}\n\nexport const logDemoTemplate = async () => {\n  const typeNode = template.typeNode('{ readonly test: string }')()\n\n  // You can use `template` as tag function.\n  const typeNodeUsingTagFn = template.typeNode`\n    {\n      readonly test: string;\n    }\n  `()\n\n  console.log(print([typeNode]))\n}\n","import ts from 'typescript'\n\nexport const print = (elements: ts.Node[], fileName = 'print.ts') => {\n  const nodes = ts.factory.createNodeArray(elements)\n  const sourceFile = ts.createSourceFile(fileName, '', ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS)\n\n  const printer = ts.createPrinter()\n  const outputFile = printer.printList(ts.ListFormat.MultiLine, nodes, sourceFile)\n\n  return outputFile\n}\n"]}

package/dist/ast/index.mjs

@@ -0,0 +1,52 @@
+import ts from 'typescript';
+import { template } from 'talt';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ast/typescript/index.ts
+var typescript_exports = {};
+__export(typescript_exports, {
+  generateStringTemplate: () => generateStringTemplate,
+  logDemoTemplate: () => logDemoTemplate,
+  print: () => print
+});
+var print = (elements, fileName = "print.ts") => {
+  const nodes = ts.factory.createNodeArray(elements);
+  const sourceFile = ts.createSourceFile(fileName, "", ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+  const printer = ts.createPrinter();
+  const outputFile = printer.printList(ts.ListFormat.MultiLine, nodes, sourceFile);
+  return outputFile;
+};
+
+// src/ast/typescript/generate.ts
+var generateStringTemplate = (templateStrings, ...placeholders) => {
+  const compiledFn = template.statement(templateStrings, ...placeholders);
+  return (params) => {
+    if (!params) {
+      return void 0;
+    }
+    const idPlaceholders = {};
+    Object.keys(params).forEach((key) => {
+      idPlaceholders[key] = typeof params[key] ? ts.factory.createStringLiteral(params[key]) : params[key];
+    });
+    const generatedAst = compiledFn(idPlaceholders);
+    return print([generatedAst]);
+  };
+};
+var logDemoTemplate = async () => {
+  const typeNode = template.typeNode("{ readonly test: string }")();
+  template.typeNode`
+    {
+      readonly test: string;
+    }
+  `();
+  console.log(print([typeNode]));
+};
+
+export { typescript_exports as typescript };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/ast/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ast/typescript/index.ts","../../src/ast/typescript/generate.ts","../../src/ast/typescript/utils/print.ts"],"names":["ts"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACGA,OAAOA,SAAQ;AACf,SAAS,gBAAgB;;;ACJzB,OAAO,QAAQ;AAER,IAAM,QAAQ,CAAC,UAAqB,WAAW,eAAe;AACnE,QAAM,QAAQ,GAAG,QAAQ,gBAAgB,QAAQ;AACjD,QAAM,aAAa,GAAG,iBAAiB,UAAU,IAAI,GAAG,aAAa,QAAQ,MAAM,GAAG,WAAW,EAAE;AAEnG,QAAM,UAAU,GAAG,cAAc;AACjC,QAAM,aAAa,QAAQ,UAAU,GAAG,WAAW,WAAW,OAAO,UAAU;AAE/E,SAAO;AACT;;;ADFO,IAAM,yBAAyB,CACpC,oBACG,iBACA;AACH,QAAM,aAAa,SAAS,UAAU,iBAAiB,GAAG,YAAY;AACtE,SAAO,CAAC,WAAqB;AAC3B,QAAI,CAAC,QAAQ;AACX,aAAO;AAAA,IACT;AACA,UAAM,iBAA0C,CAAC;AAEjD,WAAO,KAAK,MAAM,EAAE,QAAQ,CAAC,QAAQ;AACnC,qBAAe,OAAO,OAAO,OAAO,OAAOA,IAAG,QAAQ,oBAAoB,OAAO,IAAI,IAAI,OAAO;AAAA,IAClG,CAAC;AAED,UAAM,eAAe,WAAW,cAAc;AAE9C,WAAO,MAAM,CAAC,YAAY,CAAC;AAAA,EAC7B;AACF;AAEO,IAAM,kBAAkB,YAAY;AACzC,QAAM,WAAW,SAAS,SAAS,2BAA2B,EAAE;AAGhE,QAAM,qBAAqB,SAAS;AAAA;AAAA;AAAA;AAAA,IAIlC;AAEF,UAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC/B","sourcesContent":["export * from './generate'\nexport * from './utils'\n","/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable no-console */\n\nimport ts from 'typescript'\nimport { template } from 'talt'\n\nimport { print } from './utils/print'\n\nexport const generateStringTemplate = <TParams = Record<string, ts.Node | string | undefined>>(\n  templateStrings: string | TemplateStringsArray,\n  ...placeholders: (string | ts.Node)[]\n) => {\n  const compiledFn = template.statement(templateStrings, ...placeholders)\n  return (params?: TParams) => {\n    if (!params) {\n      return undefined\n    }\n    const idPlaceholders: Record<string, ts.Node> = {}\n\n    Object.keys(params).forEach((key) => {\n      idPlaceholders[key] = typeof params[key] ? ts.factory.createStringLiteral(params[key]) : params[key]\n    })\n\n    const generatedAst = compiledFn(idPlaceholders)\n\n    return print([generatedAst])\n  }\n}\n\nexport const logDemoTemplate = async () => {\n  const typeNode = template.typeNode('{ readonly test: string }')()\n\n  // You can use `template` as tag function.\n  const typeNodeUsingTagFn = template.typeNode`\n    {\n      readonly test: string;\n    }\n  `()\n\n  console.log(print([typeNode]))\n}\n","import ts from 'typescript'\n\nexport const print = (elements: ts.Node[], fileName = 'print.ts') => {\n  const nodes = ts.factory.createNodeArray(elements)\n  const sourceFile = ts.createSourceFile(fileName, '', ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS)\n\n  const printer = ts.createPrinter()\n  const outputFile = printer.printList(ts.ListFormat.MultiLine, nodes, sourceFile)\n\n  return outputFile\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,218 @@
+import { Options } from 'prettier';
+
+interface SerializablePluginCache {
+    [key: string]: [number, any];
+}
+interface Cache<TCache = any> {
+    delete(id: string): boolean;
+    get<T = TCache>(id: string): T;
+    has(id: string): boolean;
+    set<T = TCache>(id: string, value: T): void;
+}
+declare function createPluginCache(cache: SerializablePluginCache): Cache;
+
+declare const isPromise: <T>(result: WithPromise<T>) => result is Promise<T>;
+
+declare const createQueue: <TArray extends readonly any[] = readonly any[], TInput = TArray[number], TOuput = void>(arr: TArray | undefined, fun: (item: TInput) => WithPromise<TOuput>) => Promise<Awaited<TOuput>[]>;
+
+type LogType = 'error' | 'warn' | 'info';
+type LogLevel = LogType | 'silent';
+
+type WriteOptions = {
+    format: boolean;
+};
+declare const write: (data: string, path: string, options?: WriteOptions) => Promise<void>;
+
+type Listener<T> = (value?: T) => void;
+declare class Emitter<TValue = unknown, TTopics = unknown> {
+    private readonly listeners;
+    private readonly topics?;
+    constructor(topics?: TTopics[]);
+    emit(...params: [topic: TTopics, value?: TValue] | [value?: TValue]): void;
+    subscribe: (cb: Listener<TValue>) => () => void;
+    on(topic: TTopics, cb: Listener<TValue>): void;
+    destroy: () => void;
+}
+
+interface EmittedFile {
+    id: string;
+    fileName: string | undefined;
+    name: string | undefined;
+    source: string | undefined;
+    type: 'asset';
+}
+type EmitFile = (emittedFile: EmittedFile) => void;
+type Topics = 'new' | 'delete' | 'done';
+declare class FileEmitter {
+    private readonly emitter;
+    private readonly filesByReferenceId;
+    constructor(emitter?: Emitter<EmittedFile, Topics>);
+    emitFile(emitedFile: EmittedFile): void;
+    delete(fileReferenceId: string): void;
+    subscribe(...params: Parameters<typeof this$1.emitter['subscribe']>): void;
+    on(...params: Parameters<typeof this$1.emitter['on']>): void;
+    private assignReferenceId;
+    getEmittedFile: (fileReferenceId: string) => EmittedFile | undefined;
+    getFileName: (fileReferenceId: string) => string | undefined;
+}
+
+/**
+ * Get the type of the first argument in a function.
+ * @example Arg0<(a: string, b: number) => void> -> string
+ */
+type Argument0<H extends keyof PluginLifecycle> = Parameters<PluginLifecycle[H]>[0];
+declare const hooks: [keyof PluginLifecycle];
+declare class PluginDriver {
+    private readonly pluginContexts;
+    plugins: Plugin[];
+    readonly fileEmitter: FileEmitter;
+    private readonly logger?;
+    private readonly config;
+    private readonly sortedPlugins;
+    constructor(config: UserConfig, pluginCache: Record<string, SerializablePluginCache> | undefined, options: {
+        logger: BuildContext['logger'];
+    });
+    get apis(): ReadonlyMap<Plugin<PluginOptions<unknown, false, any>>, PluginContext>;
+    get api(): PluginContext;
+    emitFile(...params: Parameters<FileEmitter['emitFile']>): void;
+    resolveId: (source: string, _importer: string | undefined) => Promise<string | null | undefined>;
+    hookFirst<H extends PluginLifecycleHooks>(hookName: H, parameters: Parameters<PluginLifecycle[H]>, skipped?: ReadonlySet<Plugin> | null): Promise<ReturnType<PluginLifecycle[H]> | null>;
+    hookParallel<H extends PluginLifecycleHooks, TOuput = void>(hookName: H, parameters?: Parameters<PluginLifecycle[H]> | undefined): Promise<Awaited<TOuput>[]>;
+    hookReduceArg0<H extends PluginLifecycleHooks>(hookName: H, [argument0, ...rest]: Parameters<PluginLifecycle[H]>, reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: Plugin) => WithPromise<Argument0<H> | null>): Promise<Argument0<H>>;
+    hookSeq<H extends PluginLifecycleHooks>(hookName: H, parameters?: Parameters<PluginLifecycle[H]>): Promise<void>;
+    private getSortedPlugins;
+    /**
+     * Run an async plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The actual pluginObject to run.
+     */
+    private runHook;
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    private runHookSync;
+}
+
+declare const format: Options;
+
+type PluginOptions<UserOptions = unknown, Nested extends boolean = false, Api = any> = {
+    userOptions: UserOptions;
+    nested: Nested;
+    api: Api;
+};
+type Plugin<TOptions extends PluginOptions = PluginOptions> = {
+    name: PluginName | Omit<string, PluginName>;
+    cacheKey?: string;
+    api?: TOptions['api'];
+} & Partial<PluginLifecycle>;
+type PluginFactory<TOptions extends PluginOptions = PluginOptions> = (options: TOptions['userOptions']) => TOptions['nested'] extends true ? Array<Plugin<TOptions>> : Plugin<TOptions>;
+declare function createPlugin<TOptions extends PluginOptions = PluginOptions>(factory: PluginFactory<TOptions>): (userOptions: TOptions['userOptions']) => TOptions["nested"] extends true ? Plugin<TOptions>[] : Plugin<TOptions>;
+
+type PluginName = 'string';
+type PluginLifecycle = {
+    validate: (this: PluginContext, plugins: Plugin[]) => WithPromise<ValidationResult>;
+    buildStart: (this: PluginContext) => WithPromise<void>;
+    resolveId: (this: PluginContext, source: string, importer: string | undefined) => string | null | undefined;
+    load: (this: PluginContext, id: string) => WithPromise<TransformResult | void>;
+    transform: (this: PluginContext, code: string, id: string) => WithPromise<TransformResult>;
+    writeFile: (this: PluginContext, code: string | undefined, id: string) => WithPromise<void>;
+    buildEnd: (this: PluginContext) => WithPromise<void>;
+};
+type PluginLifecycleHooks = keyof PluginLifecycle;
+type Api = {
+    config: UserConfig & {
+        root: string;
+    };
+    schema: Schema;
+    emitFile: FileEmitter['emitFile'];
+    resolveId: (source: string, importer?: string) => WithPromise<string | null | undefined>;
+    getFileName: FileEmitter['getFileName'];
+    getEmittedFile: FileEmitter['getEmittedFile'];
+};
+type PluginContext = Api & {
+    cache: Cache;
+};
+type ValidationResult = true | {
+    message: string;
+};
+type TransformResult = string | null;
+type WithPromise<T> = Promise<T> | T;
+type Id = string;
+type Schema = string;
+
+interface ConfigEnv {
+    mode: string;
+}
+interface UserConfig {
+    /**
+     * Project root directory. Can be an absolute path, or a path relative from
+     * the location of the config file itself.
+     * @default process.cwd()
+     */
+    root?: string;
+    mode?: 'single';
+    /**
+     * plugins means it will run context, buildStart, transform and buildEnd based on order of the plugins array
+     * Example of an order(plugin x does not have a buildEnd): [buildStart of plugin x, buildStart of plugin y, transform of plugin x, transform of plugin y, buildEnd of plugin y ]
+     * Default: plugins
+     */
+    lifeCycle?: 'plugins';
+    /**
+     *  Default: fifo
+     */
+    strategy?: 'fifo' | 'lifo';
+    input: {
+        schema: string;
+    };
+    output: {
+        path: string;
+    };
+    /**
+     * Array of regenerator plugins to use.
+     */
+    plugins?: Plugin[];
+    logLevel?: LogLevel;
+}
+type UserConfigFn = (env: ConfigEnv) => WithPromise<UserConfig>;
+type UserConfigExport = WithPromise<UserConfig> | UserConfigFn;
+/**
+ * Type helper to make it easier to use regenerator.config.ts
+ * accepts a direct {@link UserConfig} object, or a function that returns it.
+ * The function receives a {@link ConfigEnv} object that exposes two properties:
+ */
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+
+type BuildOutput = void;
+type Spinner = {
+    start: (text?: string) => Spinner;
+    succeed: (text: string) => Spinner;
+    stopAndPersist: (options: {
+        text: string;
+    }) => Spinner;
+    render: () => Spinner;
+    text: string;
+    info: (text: string) => Spinner;
+};
+type BuildContext = {
+    logger?: {
+        log: (message: string, logLevel: LogLevel) => void;
+        spinner?: Spinner;
+    };
+};
+declare function build(this: BuildContext, config: UserConfig, env: ConfigEnv): Promise<BuildOutput>;
+
+declare function getPluginContext(this: PluginDriver, plugin: Plugin, pluginCache: Record<string, SerializablePluginCache> | void): {
+    cache: Cache<any>;
+};
+
+declare namespace Plugins {
+    interface Context {
+    }
+}
+
+export { Api, Argument0, BuildContext, Cache, ConfigEnv, EmitFile, EmittedFile, Emitter, FileEmitter, Id, Listener, LogLevel, LogType, Plugin, PluginContext, PluginDriver, PluginFactory, PluginLifecycle, PluginLifecycleHooks, PluginName, PluginOptions, Plugins, Schema, SerializablePluginCache, TransformResult, UserConfig, UserConfigExport, UserConfigFn, ValidationResult, WithPromise, build, createPlugin, createPluginCache, createQueue, build as default, defineConfig, format, getPluginContext, hooks, isPromise, write };