wormajs 0.0.1

package/dist/template/presets/alova/partials/typed-body.handlebars

@@ -0,0 +1,43 @@
+import type { alovaInstance } from './index';
+import type { Alova, AlovaGenerics, AlovaMethodCreateConfig, Method } from 'alova';
+
+type CollapsedAlova = typeof alovaInstance;
+
+export type Alova2MethodConfig<Responded> = CollapsedAlova extends Alova<
+  AlovaGenerics<
+    any,
+    any,
+    infer RequestConfig,
+    infer Response,
+    infer ResponseHeader,
+    infer L1Cache,
+    infer L2Cache,
+    infer SE
+  >
+>
+  ? Omit<
+      AlovaMethodCreateConfig<
+        AlovaGenerics<Responded, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>,
+        any,
+        Responded
+      >,
+      'params'
+    >
+  : never;
+
+export type Alova2Method<Responded> = CollapsedAlova extends Alova<
+  AlovaGenerics<
+    any,
+    any,
+    infer RequestConfig,
+    infer Response,
+    infer ResponseHeader,
+    infer L1Cache,
+    infer L2Cache,
+    infer SE
+  >
+>
+  ? Method<
+      AlovaGenerics<Responded, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>
+    >
+  : never;

package/dist/template/presets/alova/typescript/#index.ts.handlebars

@@ -0,0 +1,14 @@
+{{> comment}}
+import { createAlova } from 'alova';
+import fetchAdapter from 'alova/fetch';
+{{> stateshook-import}}
+
+export const alovaInstance = createAlova({
+  baseURL: "{{{baseUrl}}}",
+{{> stateshook-option}}
+  requestAdapter: fetchAdapter(),
+  beforeRequest: method => { },
+  responded: (res, method) => {
+    return method.meta?.blob ? res.blob() : res.json();
+  }
+});

package/dist/template/presets/alova/typescript/components.d.ts.handlebars

@@ -0,0 +1 @@
+{{> components-body}}

package/dist/template/presets/alova/typescript/helper.ts.handlebars

@@ -0,0 +1,9 @@
+{{> comment}}
+export function buildPayload(url: string, defaultConfig: Record<string, any>, apiName: string, config: any) {
+{{> build-payload-body}}
+}
+
+export const setMethodDefaultConfig = <
+  TagedMap extends Record<string, (config: any) => any>,
+  ConfigMap extends { [K in keyof TagedMap]?: Partial<Parameters<TagedMap[K]>[0]> },
+>(_: TagedMap, configMap: ConfigMap) => configMap;

package/dist/template/presets/alova/typescript/services/#index.ts.handlebars

@@ -0,0 +1,9 @@
+{{> comment}}
+import { setMethodDefaultConfig } from '../helper';
+{{#each tagedApis}}
+import * as {{{tagName}}} from './{{{tagName}}}';
+{{/each}}
+
+{{#each tagedApis}}
+export const {{{tagName}}}DefaultConfig = setMethodDefaultConfig({{{tagName}}}, {});
+{{/each}}

package/dist/template/presets/alova/typescript/services/{tag}.ts.handlebars

@@ -0,0 +1,35 @@
+{{> comment}}
+import { alovaInstance } from '../index';
+import { buildPayload } from '../helper';
+import type { Alova2Method, Alova2MethodConfig } from '../typed';
+{{#each tagedApis}}
+import { {{{tagName}}}DefaultConfig } from '.';
+{{/each}}
+import type * as ComponentTypes from '../components';
+
+{{#each tagedApis}}
+{{> extract-responded}}
+{{#each apis}}
+
+interface {{{name}}}ExtraConfig {
+  {{#if pathParameters}}pathParams: {{processType pathParameters @root.componentNames}};
+  {{/if}}{{#if queryParameters}}params: {{processType queryParameters @root.componentNames}};
+  {{/if}}{{#if requestBody}}data: {{processType requestBody @root.componentNames}};
+  {{/if}}
+}
+{{> api-jsdoc}}
+export function {{{name}}}<Config extends Alova2MethodConfig<{{processType response @root.componentNames}}> & {{{name}}}ExtraConfig>(config: Config): Alova2Method<ExtractResponded<Config, '{{{name}}}', {{processType response @root.componentNames}}>> {
+  const { url, data, mergedConfig } = buildPayload('{{{path}}}', {{{tag}}}DefaultConfig, {{{name}}}.name, config);
+  return alovaInstance.Request<ExtractResponded<Config, '{{{name}}}', {{processType response @root.componentNames}}>>({
+    ...mergedConfig,
+    url,
+    data,
+    method: '{{method}}',{{#if (eq response "Blob")}}
+    meta: {
+      blob: true
+    }{{/if}}
+  });
+}
+
+{{/each}}
+{{/each}}

package/dist/template/presets/alova/typescript/typed.ts.handlebars

@@ -0,0 +1 @@
+{{> typed-body}}

package/dist/template/presets/alova-globals/common/#index.cjs.handlebars

@@ -0,0 +1,41 @@
+{{> comment}}
+const { createAlova } = require('alova');
+const fetchAdapter = require('alova/fetch');
+{{#if (eq framework "vue")}}
+const vueHook = require('alova/vue');
+{{else if (eq framework "react")}}
+const reactHook = require('alova/react');
+{{else if (eq framework "svelte")}}
+const svelteHook = require('alova/svelte');
+{{else if (eq framework "solid")}}
+const solidHook = require('alova/solid');
+{{/if}}
+const { createApis, mountApis, withConfigType } = require('./createApis.cjs');
+
+const alovaInstance = createAlova({
+  baseURL: "{{{baseUrl}}}",
+{{#if (eq framework "vue")}}
+  statesHook: vueHook,
+{{else if (eq framework "react")}}
+  statesHook: reactHook,
+{{else if (eq framework "svelte")}}
+  statesHook: svelteHook,
+{{else if (eq framework "solid")}}
+  statesHook: solidHook,
+{{/if}}
+  requestAdapter: fetchAdapter(),
+  beforeRequest: method => { },
+  responded: res => {
+    return res.json();
+  }
+});
+
+const $$userConfigMap = withConfigType({});
+
+const Apis = createApis(alovaInstance, $$userConfigMap);
+
+mountApis(Apis);
+
+exports.alovaInstance = alovaInstance;
+exports.$$userConfigMap = $$userConfigMap;
+exports.Apis = Apis;

package/dist/template/presets/alova-globals/common/apiDefinitions.cjs.handlebars

@@ -0,0 +1,12 @@
+{{> comment}}
+{{#if config.useImportType}}/// <reference types='./globals.d.ts' />{{else}}/// <reference types='./globals.d.ts' />{{/if}}
+
+const apiDefinitions = {
+{{#each tagedApis}}
+  {{#apis}}
+  '{{{tag}}}.{{{name}}}': ['{{method}}', '{{{path}}}'],
+  {{/apis}}
+{{/each}}
+};
+
+module.exports = apiDefinitions;

package/dist/template/presets/alova-globals/common/createApis.cjs.handlebars

@@ -0,0 +1,48 @@
+{{> comment}}
+const { Method } = require('alova');
+const apiDefinitions = require('./apiDefinitions.cjs');
+
+{{> createApis-proxy-js}}
+/**
+ *
+ * @param {import('alova').Alova<AlovaGenerics>} alovaInstance
+ * @param {any} configMap
+ * @returns { {{{config.global}}} }
+ */
+const createApis = (alovaInstance, configMap) => {
+  const Apis = new Proxy(
+    {},
+    {
+      get(_, property) {
+        return createFunctionalProxy([property], alovaInstance, configMap);
+      }
+    }
+  );
+  return Apis;
+};
+/**
+ * @param { {{{config.global}}} } Apis
+ * @returns { void }
+ */
+const mountApis = (Apis) => {
+  ({{{config.globalHost}}}).{{{config.global}}} = Apis;
+};
+{{> withConfigType-jsdoc}}
+/**
+ * @typedef {{#raw "{{ " }}{{/raw}}
+ *  [P in keyof typeof import('./apiDefinitions')]?: MethodConfig<
+ *    P extends `${infer Tag}.${infer Url}`
+ *      ? Parameters<NonNullable<APISofParameters<Tag,Url>[0]>['transform']>[0]
+ *      : any
+ *  >
+ * {{#raw "}}" }}{{/raw}} MethodsConfigMap
+ */
+/**
+ * @template {MethodsConfigMap} Config
+ * @param {Config} config
+ */
+const withConfigType = (config) => config;
+
+exports.createApis = createApis;
+exports.mountApis = mountApis;
+exports.withConfigType = withConfigType;

package/dist/template/presets/alova-globals/common/globals.d.cts.handlebars

@@ -0,0 +1,2 @@
+{{> comment}}
+{{> globals-d-ts}}

package/dist/template/presets/alova-globals/module/#index.js.handlebars

@@ -0,0 +1,2 @@
+{{> comment}}
+{{> index-esm}}

package/dist/template/presets/alova-globals/module/apiDefinitions.js.handlebars

@@ -0,0 +1,12 @@
+{{> comment}}
+{{#if config.useImportType}}import './globals.d.ts';{{else}}/// <reference types='./globals.d.ts' />{{/if}}
+
+const apiDefinitions = {
+{{#each tagedApis}}
+  {{#apis}}
+  '{{{tag}}}.{{{name}}}': ['{{method}}', '{{{path}}}'],
+  {{/apis}}
+{{/each}}
+};
+
+export default apiDefinitions;

package/dist/template/presets/alova-globals/module/createApis.js.handlebars

@@ -0,0 +1,44 @@
+{{> comment}}
+import { Method } from 'alova';
+import apiDefinitions from './apiDefinitions.js';
+
+{{> createApis-proxy-js}}
+/**
+ *
+ * @param {import('alova').Alova<AlovaGenerics>} alovaInstance
+ * @param {any} configMap
+ * @returns { {{{config.global}}} }
+ */
+export const createApis = (alovaInstance, configMap) => {
+  const Apis = new Proxy(
+    {},
+    {
+      get(_, property) {
+        return createFunctionalProxy([property], alovaInstance, configMap);
+      }
+    }
+  );
+  return Apis;
+};
+/**
+ * @param { {{{config.global}}} } Apis
+ * @returns { void }
+ */
+export const mountApis = (Apis) => {
+  ({{{config.globalHost}}}).{{{config.global}}} = Apis;
+};
+{{> withConfigType-jsdoc}}
+/**
+ * @typedef {{#raw "{{ " }}{{/raw}}
+ *  [P in keyof typeof import('./apiDefinitions').default]?: MethodConfig<
+ *    P extends `${infer Tag}.${infer Url}`
+ *      ? Parameters<NonNullable<APISofParameters<Tag,Url>[0]>['transform']>[0]
+ *      : any
+ *  >
+ * {{#raw "}}" }}{{/raw}} MethodsConfigMap
+ */
+/**
+ * @template {MethodsConfigMap} Config
+ * @param {Config} config
+ */
+export const withConfigType = (config) => config;

package/dist/template/presets/alova-globals/module/globals.d.ts.handlebars

@@ -0,0 +1,2 @@
+{{> comment}}
+{{> globals-d-ts}}

package/dist/template/presets/alova-globals/partials/comment.handlebars

@@ -0,0 +1,19 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * {{title}} - version {{version}}
+ *
+ * {{description}}
+ *
+ * OpenAPI version: {{openapi}}
+ *
+ {{#contact}}
+ * Contact: {{#contact.name}}[{{contact.name}}]{{/contact.name}}{{#contact.url}}{{{contact.url}}}{{/contact.url}}{{^contact.url}}{{{contact.email}}}{{/contact.url}}
+ {{/contact}}
+ *
+ * NOTE: This file is auto generated by the alova's vscode plugin.
+ *
+ * https://alova.js.org/devtools/vscode
+ *
+ * **Do not edit the file manually.**
+ */

package/dist/template/presets/alova-globals/partials/createApis-proxy-js.handlebars

@@ -0,0 +1,55 @@
+const cache = Object.create(null);
+/**
+ * @typedef {import('alova').AlovaGenerics} AlovaGenerics
+ */
+/**
+ *
+ * @param {(string|symbol)[]} array
+ * @param {import('alova').Alova<AlovaGenerics>} alovaInstance
+ * @param {any} configMap
+ * @returns {()=>void}
+ */
+const createFunctionalProxy = (array, alovaInstance, configMap) => {
+  const apiPathKey = array.join('.');
+  if (cache[apiPathKey]) {
+    return cache[apiPathKey];
+  }
+  const proxy = new Proxy(function () {}, {
+    get(_, property) {
+      const newArray = [...array, property];
+      return createFunctionalProxy(newArray, alovaInstance, configMap);
+    },
+    apply(_, __, [config]) {
+      const apiItem = apiDefinitions[apiPathKey];
+      if (!apiItem) {
+        throw new Error(`the api path of \`${apiPathKey}\` is not found`);
+      }
+      const mergedConfig = {
+        ...configMap[apiPathKey],
+        ...config
+      };
+      const [method, url] = apiItem;
+      const pathParams = mergedConfig.pathParams;
+      const urlReplaced = url.replace(/\{([^}]+)\}/g, (_, key) => {
+        const pathParam = pathParams[key];
+        return pathParam;
+      });
+      delete mergedConfig.pathParams;
+      let data = mergedConfig.data;
+      if (Object.prototype.toString.call(data) === '[object Object]' && typeof FormData !== 'undefined') {
+        let hasBlobData = false;
+        const formData = new FormData();
+        for (const key in data) {
+          formData.append(key, data[key]);
+          if (data[key] instanceof Blob) {
+            hasBlobData = true;
+          }
+        }
+        data = hasBlobData ? formData : data;
+      }
+      return new Method(method.toUpperCase(), alovaInstance, urlReplaced, mergedConfig, data);
+    }
+  });
+  cache[apiPathKey] = proxy;
+  return proxy;
+};

package/dist/template/presets/alova-globals/partials/globals-d-ts.handlebars

@@ -0,0 +1,148 @@
+import type { Alova, AlovaMethodCreateConfig, AlovaGenerics, Method } from 'alova';
+import type { alovaInstance, $$userConfigMap } from './index';
+import type apiDefinitions from './apiDefinitions';
+
+type CollapsedAlova = typeof alovaInstance;
+type UserMethodConfigMap = typeof $$userConfigMap;
+
+type Alova2MethodConfig<Responded> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Omit<
+        AlovaMethodCreateConfig<
+          AlovaGenerics<Responded, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>,
+          any,
+          Responded
+        >,
+        'params'
+      >
+    : never;
+
+type ExtractUserDefinedTransformed<
+  DefinitionKey extends keyof typeof apiDefinitions,
+  Default
+> = DefinitionKey extends keyof UserMethodConfigMap
+  ? UserMethodConfigMap[DefinitionKey]['transform'] extends (...args: any[]) => any
+    ? Awaited<ReturnType<UserMethodConfigMap[DefinitionKey]['transform']>>
+    : Default
+  : Default;
+
+type Alova2Method<
+  Responded,
+  DefinitionKey extends keyof typeof apiDefinitions,
+  CurrentConfig extends Alova2MethodConfig<any>
+> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Method<
+        AlovaGenerics<
+          CurrentConfig extends undefined
+            ? ExtractUserDefinedTransformed<DefinitionKey, Responded>
+            : CurrentConfig['transform'] extends (...args: any[]) => any
+              ? Awaited<ReturnType<CurrentConfig['transform']>>
+              : ExtractUserDefinedTransformed<DefinitionKey, Responded>,
+          any,
+          RequestConfig,
+          Response,
+          ResponseHeader,
+          L1Cache,
+          L2Cache,
+          SE
+        >
+      >
+    : never;
+
+{{#each components}}
+{{{.}}}
+{{/each}}
+
+declare global {
+  interface {{{config.global}}} {
+    {{#each tagedApis}}
+    {{{tagName}}}: {
+     {{#apis}}
+      /**
+       * ---
+       *
+       * [{{{method}}}] {{{summary}}}
+       *
+       * **path:** {{{path}}}
+       *
+      {{#if pathParametersComment}}
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {{{pathParametersComment}}}
+       * ```
+       *
+       {{/if}}
+       {{#if queryParametersComment}}
+       * ---
+       *
+       * **Query Parameters**
+       * ```ts
+       * type QueryParameters = {{{queryParametersComment}}}
+       * ```
+       *
+       {{/if}}
+       {{#if requestBodyComment}}
+       * ---
+       *
+       * **RequestBody**
+       * ```ts
+       * type RequestBody = {{{requestBodyComment}}}
+       * ```
+       *
+       {{/if}}
+       {{#if responseComment}}
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {{{responseComment}}}
+       * ```
+       {{/if}}
+       */
+      {{{name}}}<Config extends Alova2MethodConfig<{{{response}}}>{{#or pathParameters queryParameters requestBody }} & {
+          {{#if pathParameters}}
+          pathParams: {{{pathParameters}}};
+          {{/if}}
+          {{#if queryParameters}}
+          params: {{{queryParameters}}};
+          {{/if}}
+          {{#if requestBody}}
+          data: {{{requestBody}}};
+          {{/if}}
+      }{{/or}}>(
+        config{{#or pathParameters queryParameters requestBody }}{{else}}?{{/or}}: Config
+      ): Alova2Method<{{{response}}}, '{{{tag}}}.{{{name}}}', Config>;
+     {{/apis}}
+    };
+    {{/each}}
+  }
+
+  var {{{config.global}}}: {{{config.global}}};
+}
+
+export {};

package/dist/template/presets/alova-globals/partials/index-esm.handlebars

@@ -0,0 +1,38 @@
+import { createAlova } from 'alova';
+import fetchAdapter from 'alova/fetch';
+{{#if (eq framework "vue")}}
+import vueHook from 'alova/vue';
+{{else if (eq framework "react")}}
+import reactHook from 'alova/react';
+{{else if (eq framework "svelte")}}
+import svelteHook from 'alova/svelte';
+{{else if (eq framework "solid")}}
+import solidHook from 'alova/solid';
+{{/if}}
+import { createApis, mountApis, withConfigType } from './createApis.js';
+
+export const alovaInstance = createAlova({
+  baseURL: "{{{baseUrl}}}",
+{{#if (eq framework "vue")}}
+  statesHook: vueHook,
+{{else if (eq framework "react")}}
+  statesHook: reactHook,
+{{else if (eq framework "svelte")}}
+  statesHook: svelteHook,
+{{else if (eq framework "solid")}}
+  statesHook: solidHook,
+{{/if}}
+  requestAdapter: fetchAdapter(),
+  beforeRequest: method => { },
+  responded: res => {
+    return res.json();
+  }
+});
+
+export const $$userConfigMap = withConfigType({});
+
+const Apis = createApis(alovaInstance, $$userConfigMap);
+
+mountApis(Apis);
+
+export { Apis };

package/dist/template/presets/alova-globals/partials/withConfigType-jsdoc.handlebars

@@ -0,0 +1,22 @@
+/**
+ * @template T
+ * @typedef {import('alova').AlovaMethodCreateConfig<
+ *  typeof import('./index')['alovaInstance'] extends import('alova').Alova<infer AG>
+ *   ? AG
+ *   : any,
+ *  any,
+ *  T
+ *>} MethodConfig
+ */
+/**
+ * @template {string} Tag
+ * @template {string} Url
+ * @typedef {Tag extends keyof {{{config.global}}}
+ *   ? Url extends keyof {{{config.global}}}[Tag]
+ *     ? {{{config.global}}}[Tag][Url] extends (...args: any) => any
+ *       ? Parameters<{{{config.global}}}[Tag][Url]>
+ *       : any
+ *     : any
+ *   : any
+ * } APISofParameters
+ */

package/dist/template/presets/alova-globals/typescript/#index.ts.handlebars

@@ -0,0 +1,2 @@
+{{> comment}}
+{{> index-esm}}

package/dist/template/presets/alova-globals/typescript/apiDefinitions.ts.handlebars

@@ -0,0 +1,12 @@
+{{> comment}}
+{{#if config.useImportType}}import './globals.d.ts';{{else}}/// <reference types='./globals.d.ts' />{{/if}}
+
+const apiDefinitions = {
+{{#each tagedApis}}
+  {{#apis}}
+  '{{{tag}}}.{{{name}}}': ['{{method}}', '{{{path}}}'],
+  {{/apis}}
+{{/each}}
+} as const;
+
+export default apiDefinitions;