150 lines
3.6 KiB
TypeScript
Executable File
150 lines
3.6 KiB
TypeScript
Executable File
import { createId } from "@paralleldrive/cuid2";
|
|
import capitalize from "lodash.capitalize";
|
|
|
|
export type GenFn<T> = (modify: (data: any) => void, data: any, arg: T) => any;
|
|
|
|
export type PropOptRaw = (string | { value: string; checked: string[] })[];
|
|
export const parseGenField = (fields: PropOptRaw) => {
|
|
const result = [] as GFCol[];
|
|
for (const f of fields) {
|
|
if (typeof f === "string") {
|
|
try {
|
|
const field = JSON.parse(f);
|
|
field["value"] = f;
|
|
result.push(field);
|
|
} catch (e) {}
|
|
} else {
|
|
const field = JSON.parse(f.value);
|
|
field.relation.fields = parseGenField(f.checked);
|
|
field["value"] = f;
|
|
result.push(field);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
export const parseOpt = <T>(gens: PropOptRaw) => {
|
|
const should_gen = {};
|
|
for (const gen of gens) {
|
|
if (typeof gen !== "string") {
|
|
(should_gen as any)[gen.value] = {};
|
|
for (const c of gen.checked) {
|
|
(should_gen as any)[gen.value][c] = true;
|
|
}
|
|
} else {
|
|
(should_gen as any)[gen] = true;
|
|
}
|
|
}
|
|
return should_gen as T;
|
|
};
|
|
|
|
export type GFCol = {
|
|
name: string;
|
|
type: string;
|
|
is_pk: boolean;
|
|
optional: boolean;
|
|
relation?: {
|
|
from: { table: string; fields: string[] };
|
|
to: { table: string; fields: string[] };
|
|
fields: GFCol[];
|
|
};
|
|
value: Array<string> | string;
|
|
};
|
|
|
|
export const formatName = (name: string) => {
|
|
return (name || "")
|
|
.split("_")
|
|
.filter((e) => e.length > 1)
|
|
.map((e) => capitalize(e))
|
|
.join(" ");
|
|
};
|
|
|
|
type SimplifiedItem = {
|
|
name?: string;
|
|
component?: {
|
|
id: string;
|
|
props: Record<
|
|
string,
|
|
string | SimplifiedItem | [any] | [any, any] | undefined
|
|
>;
|
|
};
|
|
childs?: SimplifiedItem[];
|
|
adv?: {
|
|
js: string;
|
|
jsBuilt: string;
|
|
};
|
|
padding?: any;
|
|
dim?: any;
|
|
layout?: any;
|
|
border?: any;
|
|
};
|
|
|
|
export const createItem = (arg: SimplifiedItem): any => {
|
|
let component = undefined;
|
|
|
|
if (arg.component && arg.component.id) {
|
|
component = { id: arg.component.id, props: {} as any };
|
|
|
|
if (arg.component.props) {
|
|
for (const [k, v] of Object.entries(arg.component.props)) {
|
|
if (v === undefined) continue;
|
|
if (typeof v === "object") {
|
|
if (Array.isArray(v) && v.length === 1) {
|
|
component.props[k] = {
|
|
meta: { type: "text" },
|
|
type: "string",
|
|
value: v[0],
|
|
};
|
|
} else if (Array.isArray(v) && v.length === 2) {
|
|
component.props[k] = {
|
|
meta: { type: "text" },
|
|
type: "string",
|
|
value: v[0],
|
|
valueBuilt: v[1],
|
|
};
|
|
} else {
|
|
if ((v as any)?.meta?.type) {
|
|
component.props[k] = v;
|
|
} else {
|
|
let newItem = createItem(v);
|
|
component.props[k] = {
|
|
meta: {
|
|
type: "content-element",
|
|
},
|
|
content: newItem,
|
|
value: "",
|
|
valueBuilt: "",
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
component.props[k] = {
|
|
meta: { type: "text" },
|
|
type: "string",
|
|
value: JSON.stringify(v),
|
|
valueBuilt: JSON.stringify(v),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
id: createId(),
|
|
dim: arg.dim
|
|
? arg.dim
|
|
: {
|
|
h: "full",
|
|
w: "full",
|
|
},
|
|
padding: arg.padding,
|
|
layout: arg.layout,
|
|
border: arg.border,
|
|
name: arg.name || "item",
|
|
type: "item",
|
|
component,
|
|
adv: arg.adv,
|
|
childs: arg.childs?.map(createItem) || [],
|
|
};
|
|
};
|