sonamu 0.5.7 → 0.7.0

package/dist/template/implementations/service.template.js

@@ -0,0 +1,201 @@
+import assert from "assert";
+import inflection from "inflection";
+import { diff, group, sort, unique } from "radashi";
+import { apiParamToTsCode, apiParamToTsCodeAsObject, apiParamTypeToTsType, unwrapPromiseOnce } from "../../api/code-converters.js";
+import { Sonamu } from "../../api/sonamu.js";
+import { Naite } from "../../naite/naite.js";
+import { ApiParamType } from "../../types/types.js";
+import { assertDefined } from "../../utils/utils.js";
+import { Template } from "../template.js";
+import { zodTypeToTsTypeDef } from "../zod-converter.js";
+export class Template__service extends Template {
+    constructor(){
+        super("service");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: ":target/src/services",
+            path: `${names.fs}/${names.fs}.service.ts`
+        };
+    }
+    render({ namesRecord }) {
+        Naite.t("render", {
+            namesRecord
+        });
+        const { syncer: { apis } } = Sonamu;
+        const apisForThisModel = apis.filter((api)=>api.modelName === `${namesRecord.capital}Model`);
+        // 서비스 TypeSource
+        const { lines, importKeys } = this.getTypeSource(apisForThisModel);
+        // AxiosProgressEvent 있는지 확인
+        const hasAxiosProgressEvent = apis.find((api)=>(api.options.clients ?? []).includes("axios-multipart"));
+        return {
+            ...this.getTargetAndPath(namesRecord),
+            body: lines.join("\n"),
+            importKeys: importKeys.filter((key)=>[
+                    "ListResult"
+                ].includes(key) === false),
+            customHeaders: [
+                `import { z } from 'zod';`,
+                `import qs from "qs";`,
+                `import useSWR, { type SWRResponse } from "swr";`,
+                `import { fetch, ListResult, SWRError, SwrOptions, handleConditional, swrPostFetcher, EventHandlers, SSEStreamOptions, useSSEStream } from '../sonamu.shared';`,
+                ...hasAxiosProgressEvent ? [
+                    `import { type AxiosProgressEvent } from 'axios';`
+                ] : []
+            ]
+        };
+    }
+    getTypeSource(apis) {
+        const importKeys = [];
+        // 제네릭에서 선언한 타입, importKeys에서 제외 필요
+        let typeParamNames = [];
+        const groups = group(apis, (api)=>api.modelName);
+        const body = Object.keys(groups).map((modelName)=>{
+            const methods = groups[modelName];
+            assert(methods);
+            const methodCodes = methods.map((api)=>{
+                // 컨텍스트 제외된 파라미터 리스트
+                const paramsWithoutContext = api.parameters.filter((param)=>!ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_")));
+                // 파라미터 타입 정의
+                const typeParamsDef = api.typeParameters.map((typeParam)=>{
+                    return apiParamTypeToTsType(typeParam, importKeys);
+                }).join(", ");
+                typeParamNames = typeParamNames.concat(api.typeParameters.map((typeParam)=>typeParam.id));
+                // 파라미터 정의
+                const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
+                // 파라미터 정의 (객체 형태)
+                const paramsDefAsObject = apiParamToTsCodeAsObject(paramsWithoutContext, importKeys);
+                // 리턴 타입 정의
+                const returnTypeDef = apiParamTypeToTsType(assertDefined(unwrapPromiseOnce(api.returnType)), importKeys);
+                // 페이로드 데이터 정의
+                const payloadDef = `{ ${paramsWithoutContext.map((param)=>param.name).join(", ")} }`;
+                // 기본 URL
+                const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;
+                const clients = api.options.clients ?? [];
+                return [
+                    // 클라이언트별로 생성
+                    ...sort(clients, (client)=>client === "swr" ? 0 : 1).map((client)=>{
+                        switch(client){
+                            case "axios":
+                                return this.renderAxios(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef);
+                            case "axios-multipart":
+                                return this.renderAxiosMultipart(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, paramsWithoutContext);
+                            case "swr":
+                                return this.renderSwr(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef);
+                            case "window-fetch":
+                                return this.renderWindowFetch(api, apiBaseUrl, typeParamsDef, paramsDef, payloadDef);
+                            default:
+                                return `// Not supported ${inflection.camelize(client, true)} yet.`;
+                        }
+                    }),
+                    // 스트리밍인 경우
+                    ...api.streamOptions ? [
+                        this.renderStream(api, apiBaseUrl, paramsDefAsObject)
+                    ] : []
+                ].join("\n");
+            }).join("\n\n");
+            return `export namespace ${modelName.replace(/Model$/, "Service").replace(/Frame$/, "Service")} {
+${methodCodes}
+}`;
+        }).join("\n\n");
+        return {
+            lines: [
+                body
+            ],
+            importKeys: diff(unique(importKeys), typeParamNames)
+        };
+    }
+    renderAxios(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef) {
+        const methodNameAxios = api.options.resourceName ? `get${inflection.camelize(api.options.resourceName)}` : api.methodName;
+        if (api.options.httpMethod === "GET") {
+            return `
+export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+    return fetch({
+      method: "GET",
+      url: \`${apiBaseUrl}?\${qs.stringify(${payloadDef})}\`,
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+}
+    `.trim();
+        } else {
+            return `
+export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+    return fetch({
+      method: '${api.options.httpMethod}',
+      url: \`${apiBaseUrl}\`,
+      data: ${payloadDef},
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+}
+      `.trim();
+        }
+    }
+    renderAxiosMultipart(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, paramsWithoutContext) {
+        const isMultiple = api.uploadOptions?.mode === "multiple";
+        const fileParamName = isMultiple ? "files" : "file";
+        const fileParamType = isMultiple ? "File[]" : "File";
+        const formDataDef = isMultiple ? [
+            `${fileParamName}.forEach(f => { formData.append("${fileParamName}", f) } ); `,
+            ...paramsWithoutContext.map((param)=>`formData.append('${param.name}', String(${param.name}));`)
+        ].join("\n") : [
+            `formData.append("${fileParamName}", ${fileParamName});`,
+            ...paramsWithoutContext.map((param)=>`formData.append('${param.name}', String(${param.name}));`)
+        ].join("\n");
+        const paramsDefComma = paramsDef !== "" ? ", " : "";
+        return `
+export async function ${api.methodName}${typeParamsDef}(
+  ${paramsDef}${paramsDefComma}
+  ${fileParamName}: ${fileParamType},
+  onUploadProgress?: (pe:AxiosProgressEvent) => void
+  ): Promise<${returnTypeDef}> {
+    const formData = new FormData();
+    ${formDataDef}
+    return fetch({
+      method: 'POST',
+      url: \`${apiBaseUrl}\`,
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+      onUploadProgress,
+      data: formData,
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+  }
+  `.trim();
+    }
+    renderSwr(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef) {
+        const methodNameSwr = api.options.resourceName ? `use${inflection.camelize(api.options.resourceName)}` : `use${inflection.camelize(api.methodName)}`;
+        return `  export function ${inflection.camelize(methodNameSwr, true)}${typeParamsDef}(${[
+            paramsDef,
+            "swrOptions?: SwrOptions"
+        ].filter((p)=>p !== "").join(",")}, ): SWRResponse<${returnTypeDef}, SWRError> {
+    return useSWR(handleConditional([
+      \`${apiBaseUrl}\`,
+      ${payloadDef},
+    ], swrOptions?.conditional)${api.options.httpMethod === "POST" ? ", swrPostFetcher" : ""}${api.options.timeout ? `, { loadingTimeout: ${api.options.timeout} }` : ""});
+  }`;
+    }
+    renderWindowFetch(api, apiBaseUrl, typeParamsDef, paramsDef, payloadDef) {
+        return `
+export async function ${api.methodName}${typeParamsDef}(${paramsDef}): Promise<Response> {
+    return window.fetch(\`${apiBaseUrl}?\${qs.stringify(${payloadDef})}\`${api.options.timeout ? `, { signal: AbortSignal.timeout(${api.options.timeout}) }` : ""});
+}
+    `.trim();
+    }
+    renderStream(api, apiBaseUrl, paramsDefAsObject) {
+        if (!api.streamOptions) {
+            return "// streamOptions not found";
+        }
+        const methodNameStream = api.options.resourceName ? `use${inflection.camelize(api.options.resourceName)}` : `use${inflection.camelize(api.methodName)}`;
+        const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);
+        const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);
+        return `  export function ${methodNameStreamCamelized}(
+  params: ${paramsDefAsObject},
+  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,
+  options: SSEStreamOptions) {
+    return useSSEStream<${eventsTypeDef}>(\`${apiBaseUrl}\`, params, handlers, options);
+  }`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/service.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport inflection from \"inflection\";\nimport { diff, group, sort, unique } from \"radashi\";\nimport {\n  apiParamToTsCode,\n  apiParamToTsCodeAsObject,\n  apiParamTypeToTsType,\n  unwrapPromiseOnce,\n} from \"../../api/code-converters\";\nimport type { ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport type { EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport type { TemplateOptions } from \"../../types/types\";\nimport { type ApiParam, ApiParamType } from \"../../types/types\";\nimport { assertDefined } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { zodTypeToTsTypeDef } from \"../zod-converter\";\n\nexport class Template__service extends Template {\n  constructor() {\n    super(\"service\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \":target/src/services\",\n      path: `${names.fs}/${names.fs}.service.ts`,\n    };\n  }\n\n  render({ namesRecord }: TemplateOptions[\"service\"]) {\n    Naite.t(\"render\", { namesRecord });\n\n    const {\n      syncer: { apis },\n    } = Sonamu;\n\n    const apisForThisModel = apis.filter((api) => api.modelName === `${namesRecord.capital}Model`);\n\n    // 서비스 TypeSource\n    const { lines, importKeys } = this.getTypeSource(apisForThisModel);\n\n    // AxiosProgressEvent 있는지 확인\n    const hasAxiosProgressEvent = apis.find((api) =>\n      (api.options.clients ?? []).includes(\"axios-multipart\"),\n    );\n\n    return {\n      ...this.getTargetAndPath(namesRecord),\n      body: lines.join(\"\\n\"),\n      importKeys: importKeys.filter((key) => [\"ListResult\"].includes(key) === false),\n      customHeaders: [\n        `import { z } from 'zod';`,\n        `import qs from \"qs\";`,\n        `import useSWR, { type SWRResponse } from \"swr\";`,\n        `import { fetch, ListResult, SWRError, SwrOptions, handleConditional, swrPostFetcher, EventHandlers, SSEStreamOptions, useSSEStream } from '../sonamu.shared';`,\n        ...(hasAxiosProgressEvent ? [`import { type AxiosProgressEvent } from 'axios';`] : []),\n      ],\n    };\n  }\n\n  getTypeSource(apis: ExtendedApi[]): {\n    lines: string[];\n    importKeys: string[];\n  } {\n    const importKeys: string[] = [];\n\n    // 제네릭에서 선언한 타입, importKeys에서 제외 필요\n    let typeParamNames: string[] = [];\n\n    const groups = group(apis, (api) => api.modelName);\n    const body = Object.keys(groups)\n      .map((modelName) => {\n        const methods = groups[modelName];\n        assert(methods);\n        const methodCodes = methods\n          .map((api) => {\n            // 컨텍스트 제외된 파라미터 리스트\n            const paramsWithoutContext = api.parameters.filter(\n              (param) =>\n                !ApiParamType.isContext(param.type) &&\n                !ApiParamType.isRefKnex(param.type) &&\n                !(param.optional === true && param.name.startsWith(\"_\")), // _로 시작하는 파라미터는 제외\n            );\n\n            // 파라미터 타입 정의\n            const typeParamsDef = api.typeParameters\n              .map((typeParam) => {\n                return apiParamTypeToTsType(typeParam, importKeys);\n              })\n              .join(\", \");\n            typeParamNames = typeParamNames.concat(\n              api.typeParameters.map((typeParam) => typeParam.id),\n            );\n\n            // 파라미터 정의\n            const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\n\n            // 파라미터 정의 (객체 형태)\n            const paramsDefAsObject = apiParamToTsCodeAsObject(paramsWithoutContext, importKeys);\n\n            // 리턴 타입 정의\n            const returnTypeDef = apiParamTypeToTsType(\n              assertDefined(unwrapPromiseOnce(api.returnType)),\n              importKeys,\n            );\n\n            // 페이로드 데이터 정의\n            const payloadDef = `{ ${paramsWithoutContext.map((param) => param.name).join(\", \")} }`;\n\n            // 기본 URL\n            const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n            const clients = api.options.clients ?? [];\n            return [\n              // 클라이언트별로 생성\n              ...sort(clients, (client) => (client === \"swr\" ? 0 : 1)).map((client) => {\n                switch (client) {\n                  case \"axios\":\n                    return this.renderAxios(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      payloadDef,\n                    );\n                  case \"axios-multipart\":\n                    return this.renderAxiosMultipart(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      paramsWithoutContext,\n                    );\n                  case \"swr\":\n                    return this.renderSwr(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      payloadDef,\n                    );\n                  case \"window-fetch\":\n                    return this.renderWindowFetch(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      payloadDef,\n                    );\n                  default:\n                    return `// Not supported ${inflection.camelize(client, true)} yet.`;\n                }\n              }),\n              // 스트리밍인 경우\n              ...(api.streamOptions ? [this.renderStream(api, apiBaseUrl, paramsDefAsObject)] : []),\n            ].join(\"\\n\");\n          })\n          .join(\"\\n\\n\");\n\n        return `export namespace ${modelName.replace(/Model$/, \"Service\").replace(/Frame$/, \"Service\")} {\n${methodCodes}\n}`;\n      })\n      .join(\"\\n\\n\");\n\n    return {\n      lines: [body],\n      importKeys: diff(unique(importKeys), typeParamNames),\n    };\n  }\n\n  renderAxios(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    payloadDef: string,\n  ) {\n    const methodNameAxios = api.options.resourceName\n      ? `get${inflection.camelize(api.options.resourceName)}`\n      : api.methodName;\n\n    if (api.options.httpMethod === \"GET\") {\n      return `\nexport async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n    return fetch({\n      method: \"GET\",\n      url: \\`${apiBaseUrl}?\\${qs.stringify(${payloadDef})}\\`,\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n}\n    `.trim();\n    } else {\n      return `\nexport async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n    return fetch({\n      method: '${api.options.httpMethod}',\n      url: \\`${apiBaseUrl}\\`,\n      data: ${payloadDef},\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n}\n      `.trim();\n    }\n  }\n\n  renderAxiosMultipart(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    paramsWithoutContext: ApiParam[],\n  ) {\n    const isMultiple = api.uploadOptions?.mode === \"multiple\";\n    const fileParamName = isMultiple ? \"files\" : \"file\";\n    const fileParamType = isMultiple ? \"File[]\" : \"File\";\n\n    const formDataDef = isMultiple\n      ? [\n          `${fileParamName}.forEach(f => { formData.append(\"${fileParamName}\", f) } ); `,\n          ...paramsWithoutContext.map(\n            (param) => `formData.append('${param.name}', String(${param.name}));`,\n          ),\n        ].join(\"\\n\")\n      : [\n          `formData.append(\"${fileParamName}\", ${fileParamName});`,\n          ...paramsWithoutContext.map(\n            (param) => `formData.append('${param.name}', String(${param.name}));`,\n          ),\n        ].join(\"\\n\");\n\n    const paramsDefComma = paramsDef !== \"\" ? \", \" : \"\";\n    return `\nexport async function ${api.methodName}${typeParamsDef}(\n  ${paramsDef}${paramsDefComma}\n  ${fileParamName}: ${fileParamType},\n  onUploadProgress?: (pe:AxiosProgressEvent) => void\n  ): Promise<${returnTypeDef}> {\n    const formData = new FormData();\n    ${formDataDef}\n    return fetch({\n      method: 'POST',\n      url: \\`${apiBaseUrl}\\`,\n      headers: {\n        \"Content-Type\": \"multipart/form-data\",\n      },\n      onUploadProgress,\n      data: formData,\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n  }\n  `.trim();\n  }\n\n  renderSwr(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    payloadDef: string,\n  ) {\n    const methodNameSwr = api.options.resourceName\n      ? `use${inflection.camelize(api.options.resourceName)}`\n      : `use${inflection.camelize(api.methodName)}`;\n    return `  export function ${inflection.camelize(methodNameSwr, true)}${typeParamsDef}(${[\n      paramsDef,\n      \"swrOptions?: SwrOptions\",\n    ]\n      .filter((p) => p !== \"\")\n      .join(\",\")}, ): SWRResponse<${returnTypeDef}, SWRError> {\n    return useSWR(handleConditional([\n      \\`${apiBaseUrl}\\`,\n      ${payloadDef},\n    ], swrOptions?.conditional)${api.options.httpMethod === \"POST\" ? \", swrPostFetcher\" : \"\"}${\n      api.options.timeout ? `, { loadingTimeout: ${api.options.timeout} }` : \"\"\n    });\n  }`;\n  }\n\n  renderWindowFetch(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    payloadDef: string,\n  ) {\n    return `\nexport async function ${api.methodName}${typeParamsDef}(${paramsDef}): Promise<Response> {\n    return window.fetch(\\`${apiBaseUrl}?\\${qs.stringify(${payloadDef})}\\`${\n      api.options.timeout ? `, { signal: AbortSignal.timeout(${api.options.timeout}) }` : \"\"\n    });\n}\n    `.trim();\n  }\n\n  renderStream(api: ExtendedApi, apiBaseUrl: string, paramsDefAsObject: string) {\n    if (!api.streamOptions) {\n      return \"// streamOptions not found\";\n    }\n\n    const methodNameStream = api.options.resourceName\n      ? `use${inflection.camelize(api.options.resourceName)}`\n      : `use${inflection.camelize(api.methodName)}`;\n    const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);\n\n    const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);\n\n    return `  export function ${methodNameStreamCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,\n  options: SSEStreamOptions) {\n    return useSSEStream<${eventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n  }`;\n  }\n}\n"],"names":["assert","inflection","diff","group","sort","unique","apiParamToTsCode","apiParamToTsCodeAsObject","apiParamTypeToTsType","unwrapPromiseOnce","Sonamu","Naite","ApiParamType","assertDefined","Template","zodTypeToTsTypeDef","Template__service","getTargetAndPath","names","target","path","fs","render","namesRecord","t","syncer","apis","apisForThisModel","filter","api","modelName","capital","lines","importKeys","getTypeSource","hasAxiosProgressEvent","find","options","clients","includes","body","join","key","customHeaders","typeParamNames","groups","Object","keys","map","methods","methodCodes","paramsWithoutContext","parameters","param","isContext","type","isRefKnex","optional","name","startsWith","typeParamsDef","typeParameters","typeParam","concat","id","paramsDef","paramsDefAsObject","returnTypeDef","returnType","payloadDef","apiBaseUrl","config","route","prefix","client","renderAxios","renderAxiosMultipart","renderSwr","renderWindowFetch","camelize","streamOptions","renderStream","replace","methodNameAxios","resourceName","methodName","httpMethod","timeout","trim","isMultiple","uploadOptions","mode","fileParamName","fileParamType","formDataDef","paramsDefComma","methodNameSwr","p","methodNameStream","methodNameStreamCamelized","eventsTypeDef","events"],"mappings":"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"}

package/dist/{templates → template/implementations}/view_enums_buttonset.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 export declare class Template__view_enums_buttonset extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord, componentId: string): {

package/dist/template/implementations/view_enums_buttonset.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_buttonset.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_buttonset.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,8BAA+B,SAAQ,QAAQ;;IAK1D,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM;;;;IAO9D,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,sBAAsB,CAAC;;;;;;CAiBrE"}

package/dist/template/implementations/view_enums_buttonset.template.js

@@ -0,0 +1,31 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+export class Template__view_enums_buttonset extends Template {
+    constructor(){
+        super("view_enums_buttonset");
+    }
+    getTargetAndPath(names, componentId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${componentId}ButtonSet.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+/*
+view_enums_buttonset
+${JSON.stringify({
+                key: this.key,
+                options: entityId
+            })}
+*/
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{templates → template/implementations}/view_enums_dropdown.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 export declare class Template__view_enums_dropdown extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord, enumId: string): {
@@ -14,5 +14,4 @@ export declare class Template__view_enums_dropdown extends Template {
         path: string;
     };
 }
-export declare function getLabel(entityId: string, enumId: string): string;
 //# sourceMappingURL=view_enums_dropdown.template.d.ts.map

package/dist/template/implementations/view_enums_dropdown.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_dropdown.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_dropdown.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,6BAA8B,SAAQ,QAAQ;;IAKzD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;;;;IAOzD,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,qBAAqB,CAAC;;;;;;CAmCpE"}

package/dist/template/implementations/view_enums_dropdown.template.js

@@ -0,0 +1,50 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { getLabel } from "../helpers.js";
+import { Template } from "../template.js";
+export class Template__view_enums_dropdown extends Template {
+    constructor(){
+        super("view_enums_dropdown");
+    }
+    getTargetAndPath(names, enumId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${enumId}Dropdown.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        const label = getLabel(entityId, enumId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${enumId}Label } from 'src/services/sonamu.generated';
+
+export function ${enumId}Dropdown(props: DropdownProps) {
+  const options = Object.entries(${enumId}Label).map(([key, label]) => {
+    return {
+      key,
+      value: key,
+      text: "${label}: " + label,
+    };
+  });
+  return (
+    <Dropdown
+      className="label"
+      options={options}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{templates → template/implementations}/view_enums_select.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 export declare class Template__view_enums_select extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord, enumId: string): {

package/dist/template/implementations/view_enums_select.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_select.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_select.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;;;;IAOzD,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAwClE"}

package/dist/template/implementations/view_enums_select.template.js

@@ -0,0 +1,55 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { getLabel } from "../helpers.js";
+import { Template } from "../template.js";
+export class Template__view_enums_select extends Template {
+    constructor(){
+        super("view_enums_select");
+    }
+    getTargetAndPath(names, enumId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${enumId}Select.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        const label = getLabel(entityId, enumId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${enumId}, ${enumId}Label } from 'src/services/sonamu.generated';
+
+export type ${enumId}SelectProps = {
+  placeholder?: string;
+  textPrefix?: string;
+} & DropdownProps;
+export function ${enumId}Select({placeholder, textPrefix, ...props}: ${enumId}SelectProps) {
+  const typeOptions = ${enumId}.options.map((key) => ({
+    key,
+    value: key,
+    text: (textPrefix ?? '${label}: ') + ${enumId}Label[key],
+  }));
+
+  return (
+    <Dropdown
+      placeholder={placeholder ?? "${label}"}
+      selection
+      options={typeOptions}
+      selectOnBlur={false}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{templates → template/implementations}/view_form.template.d.ts

@@ -1,6 +1,6 @@
-import { RenderingNode, TemplateKey, TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { RenderingNode, TemplateKey, TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 export declare class Template__view_form extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {
@@ -12,7 +12,7 @@ export declare class Template__view_form extends Template {
     renderColumnImport(entityId: string, col: RenderingNode): string;
     renderColumn(entityId: string, col: RenderingNode, names: EntityNamesRecord, parent?: string): string;
     resolveDefaultValue(columns: RenderingNode[]): object;
-    render({ entityId }: TemplateOptions["view_form"], saveParamsNode: RenderingNode): {
+    render({ entityId }: TemplateOptions["view_form"]): Promise<{
         body: string;
         importKeys: never[];
         preTemplates: {
@@ -21,6 +21,6 @@ export declare class Template__view_form extends Template {
         }[];
         target: string;
         path: string;
-    };
+    }>;
 }
 //# sourceMappingURL=view_form.template.d.ts.map

package/dist/template/implementations/view_form.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_form.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_form.template.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGrF,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAI5C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa;IAmBvD,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,iBAAiB,EACxB,MAAM,GAAE,MAAW,GAClB,MAAM;IA6DT,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM;IAqC/C,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC;;;;;;;;;;CAoOxD"}