Refactoring: merge types from src/api/mustache/types/* to src/api/mustache/types.ts.

Author: ryukzak

src/api/mustache/generator/DebugMixinProvider.ts

@@ -1,4 +1,4 @@
-import type { DebugMixin } from "@mustache/types/DebugMixin";
+import type { DebugMixin } from "@mustache/types";
 
 export class DebugMixinProvider {
     constructor(private readonly mode: "FORMATTED" | "COMPACT") {}

src/api/mustache/generator/LambdaMixinProvider.ts

@@ -1,5 +1,5 @@
 import type { NameGenerator } from "@mustache/generator/NameGenerator";
-import type { LambdaMixin } from "@mustache/types/LambdaMixin";
+import type { LambdaMixin } from "@mustache/types";
 import { camelCase, kebabCase, pascalCase, snakeCase } from "@root/api/writer-generator/utils";
 
 export class LambdaMixinProvider {

src/api/mustache/generator/ListElementInformationMixinProvider.ts

@@ -1,4 +1,4 @@
-import type { ListElementInformationMixin } from "@mustache/types/ListElementInformationMixin";
+import type { ListElementInformationMixin } from "@mustache/types";
 
 export class ListElementInformationMixinProvider {
     private static _array<T>(value: T[] | Set<T>): T[] {

src/api/mustache/generator/SchemaLoaderFacade.ts

@@ -1,4 +1,4 @@
-import type { FilterType } from "@mustache/types/FilterType";
+import type { FilterType } from "@mustache/types";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
 import type { Identifier, RegularTypeSchema, TypeSchema } from "@typeschema/types";
 

src/api/mustache/generator/TemplateFileCache.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import Path from "node:path";
-import type { Rendering } from "@mustache/types/Rendering";
+import type { Rendering } from "@mustache/types";
 
 export class TemplateFileCache {
     private readonly templateBaseDir: string;

src/api/mustache/generator/ViewModelFactory.ts

@@ -1,14 +1,16 @@
 import { ListElementInformationMixinProvider } from "@mustache/generator/ListElementInformationMixinProvider";
 import type { NameGenerator } from "@mustache/generator/NameGenerator";
 import type { SchemaLoaderFacade } from "@mustache/generator/SchemaLoaderFacade";
-import type { EnumViewModel } from "@mustache/types/EnumViewModel";
-import type { FieldViewModel } from "@mustache/types/FieldViewModel";
-import type { NamedViewModel } from "@mustache/types/NamedViewModel";
-import { PRIMITIVE_TYPES } from "@mustache/types/PrimitiveType";
-import type { ResolvedTypeViewModel } from "@mustache/types/ResolvedTypeViewModel";
-import type { RootViewModel } from "@mustache/types/RootViewModel";
-import type { TypeViewModel } from "@mustache/types/TypeViewModel";
-import type { ViewModel } from "@mustache/types/ViewModel";
+import type {
+    EnumViewModel,
+    FieldViewModel,
+    NamedViewModel,
+    ResolvedTypeViewModel,
+    RootViewModel,
+    TypeViewModel,
+    ViewModel,
+} from "@mustache/types";
+import { PRIMITIVE_TYPES } from "@mustache/types";
 import type { IsPrefixed } from "@mustache/UtilityTypes";
 import type { Field, Identifier, NestedType, TypeSchema } from "@typeschema/types";
 

src/api/mustache/types.ts

@@ -0,0 +1,163 @@
+import type { Field, NestedType, TypeSchema } from "@typeschema/types";
+import type { IsPrefixed } from "@mustache/UtilityTypes";
+
+export type DebugMixin = {
+    debug: string;
+};
+
+export type EnumValueViewModel = {
+    name: string;
+    saveName: string;
+};
+
+export type EnumViewModel = NamedViewModel & {
+    values: EnumValueViewModel[];
+};
+
+export type FieldViewModel = {
+    owner: NamedViewModel;
+
+    schema: Field;
+    name: string;
+    saveName: string;
+
+    typeName: string;
+
+    isSizeConstrained: boolean;
+    min?: number;
+    max?: number;
+
+    isArray: boolean;
+    isRequired: boolean;
+    isEnum: boolean;
+
+    isPrimitive: Record<IsPrefixed<PrimitiveType>, boolean> | false;
+    isComplexType: Record<IsPrefixed<string>, boolean> | false;
+    isResource: Record<IsPrefixed<string>, boolean> | false;
+
+    isCode: boolean;
+    isIdentifier: boolean;
+    isReference: boolean;
+};
+
+export type FilterType = {
+    whitelist?: (string | RegExp)[];
+    blacklist?: (string | RegExp)[];
+};
+
+export type HookType = {
+    cmd: string;
+    args?: string[];
+};
+
+export type LambdaMixin = {
+    lambda: {
+        saveEnumValueName: () => (text: string, render: (input: string) => string) => string;
+        saveFieldName: () => (text: string, render: (input: string) => string) => string;
+        saveTypeName: () => (text: string, render: (input: string) => string) => string;
+
+        camelCase: () => (text: string, render: (input: string) => string) => string;
+        snakeCase: () => (text: string, render: (input: string) => string) => string;
+        pascalCase: () => (text: string, render: (input: string) => string) => string;
+        kebabCase: () => (text: string, render: (input: string) => string) => string;
+        lowerCase: () => (text: string, render: (input: string) => string) => string;
+        upperCase: () => (text: string, render: (input: string) => string) => string;
+    };
+};
+
+export type ListElementInformationMixin = {
+    "-index": number;
+    "-length": number;
+    "-last": boolean;
+    "-first": boolean;
+};
+
+export type NamedViewModel = {
+    name: string;
+    saveName: string;
+};
+
+export const PRIMITIVE_TYPES = [
+    "boolean",
+    "instant",
+    "time",
+    "date",
+    "dateTime",
+
+    "decimal",
+    "integer",
+    "unsignedInt",
+    "positiveInt",
+    "integer64",
+    "base64Binary",
+
+    "uri",
+    "url",
+    "canonical",
+    "oid",
+    "uuid",
+
+    "string",
+    "code",
+    "markdown",
+    "id",
+    "xhtml",
+] as const;
+
+export type PrimitiveType = (typeof PRIMITIVE_TYPES)[number];
+
+export type Rendering = {
+    source: string;
+    fileNameFormat: string;
+    path: string;
+    filter?: FilterType;
+    properties?: Record<string, any>;
+};
+
+export type ResolvedTypeViewModel = TypeViewModel & {
+    allFields: FieldViewModel[];
+    inheritedFields: FieldViewModel[];
+    parents: TypeViewModel[];
+    children: TypeViewModel[];
+
+    hasChildren: boolean;
+    hasParents: boolean;
+    hasInheritedFields: boolean;
+};
+
+export type RootViewModel<T> = T & {
+    resources: { name: string; saveName: string }[];
+    complexTypes: { name: string; saveName: string }[];
+};
+
+export type TypeViewModel = NamedViewModel & {
+    schema: TypeSchema | NestedType;
+    fields: FieldViewModel[];
+
+    dependencies: {
+        resources: NamedViewModel[];
+        complexTypes: NamedViewModel[];
+    };
+
+    hasFields: boolean;
+    hasNestedComplexTypes: boolean;
+    hasNestedEnums: boolean;
+
+    isNested: boolean;
+    isComplexType: Record<IsPrefixed<string>, boolean> | false;
+    isResource: Record<IsPrefixed<string>, boolean> | false;
+
+    nestedComplexTypes: ResolvedTypeViewModel[];
+    nestedEnums: EnumViewModel[];
+};
+
+export type View<T extends ViewModel> = LambdaMixin & {
+    model: T;
+    meta: {
+        timestamp: string;
+        generator: string;
+    };
+    properties: Record<string, unknown>;
+};
+
+export type ViewModel = Record<string, unknown>;