mac/behavior3editor
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

print all build errors at the end

Browse Source
This commit is contained in:
codetypes committed 2025-10-17 16:34:02 +08:00
1 parent 05cce8f91f
commit c137b880b3
8 files changed
+424 -93
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

package-lock.json
Generated
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "behavior3editor",
"version": "1.8.5",
"version": "1.8.7",
"lockfileVersion": 2,
"requires": true,
"packages": {
"": {
"name": "behavior3editor",
"version": "1.8.5",
"version": "1.8.7",
"hasInstallScript": true,
"license": "MIT",
"dependencies": {
package.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "behavior3editor",
"version": "1.8.5",
"version": "1.8.7",
"main": "dist-electron/main/index.js",
"description": "行为树编辑器",
"author": "zhandouxiaojiji & codetypes",
src/components/inspector.tsx
+1 -1
View File
@@ -549,7 +549,7 @@ const validateArg = (
} else if (value === null && !required) {
value = undefined;
}
if (!checkNodeArgValue(node, arg, value, true)) {
if (!checkNodeArgValue(node, arg, value, console.error)) {
return Promise.reject(new Error(i18n.t("node.invalidValue")));
}
return Promise.resolve(value);
src/components/register-node.ts
+1 -1
View File
@@ -748,7 +748,7 @@ class TreeNode extends Rect {
!b3util.nodeDefs.has(data.name) ||
(data.path && !node.children?.length) ||
(nodeDef.group && !nodeDef.group.some((g) => b3util.usingGroups?.[g])) ||
!b3util.checkTreeData(data) ||
!b3util.isValidNodeData(data) ||
foundUndefined(data.input) ||
foundUndefined(data.output) ||
foundUndefinedInArgs(nodeDef, data) ||
src/misc/b3type.ts
+2 -1
View File
@@ -1,6 +1,6 @@
import { NodeDef } from "../behavior3/src/behavior3";
export const VERSION = "1.8.5";
export const VERSION = "1.8.7";
export const keyWords = ["true", "false", "null", "undefined", "NaN", "Infinity"];
@@ -73,6 +73,7 @@ export interface TreeData {
group: string[];
import: string[];
vars: VarDecl[];
custom: Record<string, string | number | boolean | object>;
root: NodeData;
$override: {
src/misc/b3util.ts
+80 -86
View File
@@ -20,10 +20,11 @@ import {
VERSION,
} from "./b3type";
import Path from "./path";
import { stringifyJson } from "./stringify";
import { nanoid, readJson, readTree, readWorkspace } from "./util";
export class NodeDefs extends Map<string, NodeDef> {
get(key: string): NodeDef {
override get(key: string): NodeDef {
return super.get(key) ?? unknownNodeDef;
}
}
@@ -188,8 +189,10 @@ export const isNodeEqual = (node1: NodeData, node2: NodeData) => {
return false;
};
const error = (data: NodeData, msg: string) => {
console.error(`check ${data.id}|${data.name}: ${msg}`);
type ErrorPrinter = (msg: string) => void;
const formatError = (data: NodeData, msg: string) => {
return `check ${data.id}|${data.name}: ${msg}`;
};
export const getNodeArgRawType = (arg: NodeArg) => {
@@ -208,75 +211,62 @@ export const checkNodeArgValue = (
data: NodeData,
arg: NodeArg,
value: unknown,
verbose?: boolean
printer?: ErrorPrinter
) => {
let hasError = false;
const type = getNodeArgRawType(arg);
const error = !printer ? () => {} : (msg: string) => printer(formatError(data, msg));
if (isFloatType(type)) {
const isNumber = typeof value === "number";
const isOptional = value === undefined && isNodeArgOptional(arg);
if (!(isNumber || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not a number`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not a number`);
hasError = true;
}
} else if (isIntType(type)) {
const isInt = typeof value === "number" && value === Math.floor(value);
const isOptional = value === undefined && isNodeArgOptional(arg);
if (!(isInt || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not a int`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not a int`);
hasError = true;
}
} else if (isStringType(type)) {
const isString = typeof value === "string" && value;
const isOptional = (value === undefined || value === "") && isNodeArgOptional(arg);
if (!(isString || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not a string`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not a string`);
hasError = true;
}
} else if (isExprType(type)) {
const isExpr = typeof value === "string" && value;
const isOptional = (value === undefined || value === "") && isNodeArgOptional(arg);
if (!(isExpr || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not an expr string`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not an expr string`);
hasError = true;
}
} else if (isJsonType(type)) {
const isJson = value !== undefined && value !== "";
const isOptional = isNodeArgOptional(arg);
if (!(isJson || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${value}' is not an invalid object`);
}
error(`'${arg.name}=${value}' is not an invalid object`);
hasError = true;
}
} else if (isBoolType(type)) {
const isBool = typeof value === "boolean" || value === undefined;
if (!isBool) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not a boolean`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not a boolean`);
hasError = true;
}
} else {
hasError = true;
error(data, `unknown arg type '${arg.type}'`);
error(`unknown arg type '${arg.type}'`);
}
if (hasArgOptions(arg)) {
const found = !!arg.options?.find((option) => option.value === value);
const isOptional = value === undefined && isNodeArgOptional(arg);
if (!(found || isOptional)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not a one of the option values`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not a one of the option values`);
hasError = true;
}
}
@@ -284,37 +274,34 @@ export const checkNodeArgValue = (
return !hasError;
};
export const checkNodeArg = (data: NodeData, conf: NodeDef, i: number, verbose?: boolean) => {
export const checkNodeArg = (data: NodeData, conf: NodeDef, i: number, printer?: ErrorPrinter) => {
let hasError = false;
const arg = conf.args![i] as NodeArg;
const value = data.args?.[arg.name];
const error = !printer ? () => {} : (msg: string) => printer(formatError(data, msg));
if (isNodeArgArray(arg)) {
if (!Array.isArray(value) || value.length === 0) {
if (!isNodeArgOptional(arg)) {
if (verbose) {
error(data, `'${arg.name}=${JSON.stringify(value)}' is not an array or empty array`);
}
error(`'${arg.name}=${JSON.stringify(value)}' is not an array or empty array`);
hasError = true;
}
} else {
for (let j = 0; j < value.length; j++) {
if (!checkNodeArgValue(data, arg, value[j], verbose)) {
if (!checkNodeArgValue(data, arg, value[j], printer)) {
hasError = true;
}
}
}
} else if (!checkNodeArgValue(data, arg, value, verbose)) {
} else if (!checkNodeArgValue(data, arg, value, printer)) {
hasError = true;
}
if (arg.oneof !== undefined) {
const idx = conf.input?.findIndex((v) => v.startsWith(arg.oneof!)) ?? -1;
if (!checkOneof(arg, data.args?.[arg.name], data.input?.[idx])) {
if (verbose) {
error(
data,
`only one is allowed for between argument '${arg.name}' and input '${data.input?.[idx]}'`
);
}
hasError = true;
}
}
@@ -333,13 +320,44 @@ export const checkOneof = (arg: NodeArg, argValue: unknown, inputValue: unknown)
return (argValue !== "" && inputValue === "") || (argValue === "" && inputValue !== "");
};
export const checkNodeData = (data: NodeData | null | undefined) => {
export const isValidNodeData = (data: NodeData) => {
const def = nodeDefs.get(data.name);
if (def.input) {
for (let i = 0; i < def.input.length; i++) {
if (!isValidInputOrOutput(def.input, data.input, i)) {
return false;
}
}
}
if (def.output) {
for (let i = 0; i < def.output.length; i++) {
if (!isValidInputOrOutput(def.output, data.output, i)) {
return false;
}
}
}
if (!isValidChildren(data)) {
return false;
}
if (def.args) {
for (let i = 0; i < def.args.length; i++) {
if (!checkNodeArg(data, def, i)) {
return false;
}
}
}
return true;
};
const checkNodeData = (data: NodeData | null | undefined, printer: ErrorPrinter) => {
if (!data) {
return false;
}
const error = !printer ? () => {} : (msg: string) => printer(formatError(data, msg));
const conf = nodeDefs.get(data.name);
if (conf.name === unknownNodeDef.name) {
error(data, `undefined node: ${data.name}`);
error(`undefined node: ${data.name}`);
return false;
}
@@ -347,7 +365,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
if (conf.group) {
if (!conf.group.some((g) => usingGroups?.[g])) {
error(data, `node group '${conf.group}' is not enabled`);
error(`node group '${conf.group}' is not enabled`);
hasError = true;
}
}
@@ -356,7 +374,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
if (data.input) {
for (const v of data.input) {
if (v && !usingVars[v]) {
error(data, `input variable '${v}' is not defined`);
error(`input variable '${v}' is not defined`);
hasError = true;
}
}
@@ -364,7 +382,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
if (data.output) {
for (const v of data.output) {
if (v && !usingVars[v]) {
error(data, `output variable '${v}' is not defined`);
error(`output variable '${v}' is not defined`);
hasError = true;
}
}
@@ -386,7 +404,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
}
for (const v of vars) {
if (v && !usingVars[v]) {
error(data, `expr variable '${arg.name}' is not defined`);
error(`expr variable '${arg.name}' is not defined`);
hasError = true;
}
}
@@ -403,11 +421,11 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
for (const expr of exprs) {
try {
if (!new ExpressionEvaluator(expr).dryRun()) {
error(data, `expr '${expr}' is not valid`);
error(`expr '${expr}' is not valid`);
hasError = true;
}
} catch (e) {
error(data, `expr '${expr}' is not valid`);
error(`expr '${expr}' is not valid`);
hasError = true;
}
}
@@ -420,7 +438,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
const count = data.children?.length || 0;
if (conf.children !== count) {
hasError = true;
error(data, `expect ${conf.children} children, but got ${count}`);
error(`expect ${conf.children} children, but got ${count}`);
}
}
@@ -435,14 +453,13 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
}
if (data.input[i] && !isValidVariableName(data.input[i])) {
error(
data,
`input field '${data.input[i]}' is not a valid variable name,` +
`should start with a letter or underscore`
);
hasError = true;
}
if (!isValidInputOrOutput(conf.input, data.input, i)) {
error(data, `intput field '${conf.input[i]}' is required`);
error(`intput field '${conf.input[i]}' is required`);
hasError = true;
}
if (i === conf.input.length - 1 && conf.input.at(-1)?.endsWith("...")) {
@@ -465,14 +482,13 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
}
if (data.output[i] && !isValidVariableName(data.output[i])) {
error(
data,
`output field '${data.output[i]}' is not a valid variable name,` +
`should start with a letter or underscore`
);
hasError = true;
}
if (!isValidInputOrOutput(conf.output, data.output, i)) {
error(data, `output field '${conf.output[i]}' is required`);
error(`output field '${conf.output[i]}' is required`);
hasError = true;
}
if (i === conf.output.length - 1 && conf.output.at(-1)?.endsWith("...")) {
@@ -496,7 +512,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
args[key] = value;
}
if (!checkNodeArg(data, conf, i, true)) {
if (!checkNodeArg(data, conf, i, printer)) {
hasError = true;
}
}
@@ -505,7 +521,7 @@ export const checkNodeData = (data: NodeData | null | undefined) => {
if (data.children) {
for (const child of data.children) {
if (!checkNodeData(child)) {
if (!checkNodeData(child, printer)) {
hasError = true;
}
}
@@ -665,36 +681,6 @@ const isValidInputOrOutput = (def: string[], data: string[] | undefined, index:
return def[index].includes("?") || data?.[index] || isVariadic(def, index);
};
export const checkTreeData = (data: NodeData) => {
const def = nodeDefs.get(data.name);
if (def.input) {
for (let i = 0; i < def.input.length; i++) {
if (!isValidInputOrOutput(def.input, data.input, i)) {
return false;
}
}
}
if (def.output) {
for (let i = 0; i < def.output.length; i++) {
if (!isValidInputOrOutput(def.output, data.output, i)) {
return false;
}
}
}
if (!isValidChildren(data)) {
return false;
}
if (def.args) {
for (let i = 0; i < def.args.length; i++) {
if (!checkNodeArg(data, def, i, false)) {
return false;
}
}
}
return true;
};
export const refreshNodeData = (tree: TreeData, node: NodeData, id: number) => {
node.id = (id++).toString();
node.$size = calcSize(node);
@@ -721,8 +707,8 @@ export const refreshNodeData = (tree: TreeData, node: NodeData, id: number) => {
const subtreePath = workdir + "/" + node.path;
const subtree = readTree(subtreePath);
id = refreshNodeData(subtree, subtree.root, --id);
node.name = subtree.name;
node.desc = subtree.desc;
node.name = subtree.root.name;
node.desc = subtree.root.desc;
node.args = subtree.root.args;
node.input = subtree.root.input;
node.output = subtree.root.output;
@@ -761,6 +747,8 @@ export const createBuildData = (path: string) => {
dfs(treeModel.root, (node) => (node.id = treeModel.prefix + node.id));
treeModel.name = Path.basenameWithoutExt(path);
treeModel.root = createFileData(treeModel.root, true);
dfs(treeModel.root, (node) => delete (node as Partial<NodeData>).$id);
delete (treeModel as Partial<TreeData>).$override;
return treeModel as TreeData;
} catch (e) {
console.log("build error:", path, e);
@@ -826,6 +814,7 @@ export const buildProject = async (project: string, buildDir: string) => {
});
}
const allErrors: string[] = [];
for (const path of Path.ls(Path.dirname(project), true)) {
if (path.endsWith(".json")) {
const buildpath = buildDir + "/" + path.substring(workdir.length + 1);
@@ -843,7 +832,6 @@ export const buildProject = async (project: string, buildDir: string) => {
}
console.log("build:", buildpath);
if (errors.length) {
errors.forEach((msg) => console.error(msg));
hasError = true;
}
const declare: FileVarDecl = {
@@ -852,14 +840,19 @@ export const buildProject = async (project: string, buildDir: string) => {
subtree: [],
};
refreshVarDecl(tree.root, tree.group, declare);
if (!checkNodeData(tree?.root)) {
if (!checkNodeData(tree?.root, (msg) => errors.push(msg))) {
hasError = true;
}
if (errors.length) {
allErrors.push(`${path}:`);
errors.forEach((v) => allErrors.push(` ${v}`));
}
buildScript?.onWriteFile?.(buildpath, tree);
fs.mkdirSync(Path.dirname(buildpath), { recursive: true });
fs.writeFileSync(buildpath, JSON.stringify(tree, null, 2));
fs.writeFileSync(buildpath, stringifyJson(tree, { indent: 2 }));
}
}
allErrors.forEach((v) => console.error(v));
buildScript?.onComplete?.(hasError ? "failure" : "success");
return hasError;
};
@@ -930,6 +923,7 @@ export const createNewTree = (path: string) => {
name: "Sequence",
$id: nanoid(),
},
custom: {},
$override: {},
};
return tree;
@@ -1017,7 +1011,7 @@ const collectSubtree = (data: NodeData) => {
export const refreshVarDecl = (root: NodeData, group: string[], declare: FileVarDecl) => {
const filter: Record<string, boolean> = {};
const vars: Array<VarDecl> = new (class extends Array {
push(...items: VarDecl[]): number {
override push(...items: VarDecl[]): number {
for (const v of items) {
if (filter[v.name]) {
continue;
src/misc/stringify.ts
+332
View File
@@ -0,0 +1,332 @@
import * as fs from "node:fs";
import { basename, dirname, extname } from "node:path";
export type Tag = {
/** data name */
["!name"]?: string;
/** type tag */
["!type"]?: string;
/** special stringify function */
["!stringify"]?: (v: TValue, ctx: StringifyContext) => void;
/** ignore fields when stringify */
["!ignore"]?: { [k: string]: boolean };
};
export type TValue = boolean | number | string | null | undefined | TObject | TArray;
export type TObject = { [k: string | number]: TValue } & Tag;
export type TArray = TValue[] & Tag;
export class StringBuffer {
readonly data: string[] = [];
private _indent: number;
private _indentCount: number = 0;
constructor(indent: number) {
this._indent = indent;
}
get indentCount() {
return this._indentCount;
}
indent() {
this._indentCount += this._indent;
}
unindent() {
this._indentCount -= this._indent;
}
padding() {
if (this._indent > 0) {
this.data.push(" ".repeat(this._indentCount));
}
}
linefeed() {
if (this._indent > 0) {
this.data.push("\n");
}
}
writeLine(value: string) {
this.padding();
this.data.push(value);
this.linefeed();
}
writeLines(value: string) {
for (const line of value.split("\n")) {
this.writeLine(line);
}
}
writeString(value: string) {
this.data.push(value);
}
toString() {
return this.data.join("");
}
}
export const isNumericKey = (key: string) => {
if (typeof key !== "string") return false;
// integer or bigint
if (/^-?\d+$/.test(key)) {
try {
return String(BigInt(key)) === key;
} catch {
return false;
}
}
// float
const num = Number(key);
return !isNaN(num) && String(num) === key;
};
export const escape = (value: string) => {
return value
.replaceAll("\r\n", "\n")
.replaceAll("\\", "\\\\")
.replaceAll('"', '\\"')
.replaceAll("\n", "\\n")
.replaceAll("\t", "\\t")
.replaceAll("\r", "\\r")
.replaceAll("\b", "\\b")
.replaceAll("\f", "\\f");
};
export const outdent = (value: string) => {
value = value.replace(/^\n/, "");
value = value.replace(/\n *$/, "");
const space = value.match(/^ +/gm)?.[0];
return space ? value.replace(new RegExp(`^${space}`, "gm"), "") : value;
};
export const format = (str: string, vars: Record<string, string>) => {
const lines: string[] = [];
for (const line of str.split(/\n|\r\n/)) {
if (line.match(/^\s*%{\w+}\s*$/)) {
const [_, space, key] = line.match(/^(\s*)%{(\w+)}$/)!;
if (vars[key] !== undefined && vars[key] !== null) {
for (const l of vars[key].split(/\n|\r\n/)) {
lines.push(space + l);
}
} else {
throw new Error(`variable '${key}' not found`);
}
} else {
lines.push(
line.replaceAll(/%{(\w+)}/g, (_, key) => {
if (vars[key] !== undefined && vars[key] !== null) {
return vars[key];
}
throw new Error(`variable '${key}' not found`);
})
);
}
}
return lines.join("\n");
};
export const keys = (
o: object,
filter?: (v: TValue) => boolean,
ignore?: { [k: string]: boolean }
) => {
const value = o as TObject;
const ks = Object.keys(value).filter(
(k) => !k.startsWith("!") && (!ignore || !ignore[k]) && (!filter || filter(value[k]))
);
const numKeys: string[] = [];
const strKeys: string[] = [];
for (const k of ks) {
const num = Number(k);
if (!isNaN(num) && isFinite(num)) {
numKeys.push(k);
} else {
strKeys.push(k);
}
}
numKeys.sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
strKeys.sort((a, b) => a.localeCompare(b));
return [...numKeys, ...strKeys];
};
export const values = <T>(
o: TObject,
filter?: (v: TValue) => boolean,
ignore?: { [k: string]: boolean }
): T[] => {
return keys(o, filter, ignore).map((k) => o[k] as T);
};
export const toPascalCase = (str: string): string => {
return str
.replace(/^_+/, "")
.replace(/_([a-zA-Z])/g, (_, letter) => letter.toUpperCase())
.replace(/^[a-zA-Z]/, (match) => match.toUpperCase());
};
export const readFile = (path: string) => {
if (fs.existsSync(path)) {
return fs.readFileSync(path, "utf-8");
}
return null;
};
export const writeFile = (path: string, data: string) => {
const dir = dirname(path);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
if (fs.existsSync(path) && readFile(path) === data) {
console.log(`up-to-date: ${path}`);
} else {
console.log(`write: ${path}`);
fs.writeFileSync(path, data, { encoding: "utf-8" });
}
};
export const writeJson = (path: string, data: TValue, options?: JsonStringifyOption) => {
options = options ?? {};
options.indent = options.indent ?? 2;
options.precision = options.precision ?? 10;
writeFile(path, stringifyJson(data, options));
};
export const filename = (path: string, suffix: boolean = false) => {
return basename(path, !suffix ? extname(path) : undefined);
};
export type StringifyContext = {
readonly format: "json" | "lua" | "ts" | string;
readonly indent: number;
readonly precision?: number;
readonly buffer: StringBuffer;
readonly writeValue: (value: TValue) => void;
readonly writeArray: (value: TArray) => void;
readonly writeObject: (value: TObject) => void;
};
const numberToString = (value: number, precision?: number) => {
if (value === (value | 0)) {
return value.toFixed(0);
} else {
return value.toFixed(precision).replace(/\.?0+$/, "");
}
};
//-----------------------------------------------------------------------------
// Json
//-----------------------------------------------------------------------------
export type JsonStringifyOption = {
indent?: number;
precision?: number;
};
export const stringifyJson = (data: unknown, option?: JsonStringifyOption) => {
const stacks: string[] = [];
option = option ?? {};
option.indent = Math.max(option.indent ?? 4, 0);
option.precision = option.precision ?? 10;
const buffer = new StringBuffer(option.indent);
const ctx: StringifyContext = {
format: "json",
indent: option.indent,
precision: option.precision,
buffer,
writeValue: writeJsonValue,
writeArray: writeJsonArray,
writeObject: writeJsonObject,
};
function writeJsonValue(value: TValue) {
if (typeof value === "number") {
buffer.writeString(numberToString(value, ctx.precision));
} else if (typeof value === "boolean") {
buffer.writeString(value.toString());
} else if (value === null || value === undefined) {
buffer.writeString("null");
} else if (typeof value === "string") {
buffer.writeString('"');
buffer.writeString(escape(value));
buffer.writeString('"');
} else if (Array.isArray(value)) {
writeJsonArray(value);
} else {
if (typeof value !== "object" || value === null || value === undefined) {
writeJsonValue(value);
} else if (Array.isArray(value)) {
writeJsonArray(value);
} else {
writeJsonObject(value as TObject);
}
}
}
function writeJsonObject(value: TObject) {
if (stacks.length > 256) {
throw new Error(`json stringify stack overflow: ${stacks.join("->")}`);
}
if (value["!stringify"]) {
value["!stringify"](value, ctx);
return;
}
const ks = keys(value, undefined, value["!ignore"]);
const space = ctx.indent > 0 ? " " : "";
buffer.writeString("{");
buffer.linefeed();
buffer.indent();
for (let i = 0; i < ks.length; i++) {
const k = ks[i];
const v = value[k];
stacks.push(k);
buffer.padding();
buffer.writeString(`"${k}":${space}`);
writeJsonValue(v);
if (i < ks.length - 1) {
buffer.writeString(",");
}
buffer.linefeed();
stacks.pop();
}
buffer.unindent();
buffer.padding();
buffer.writeString("}");
}
function writeJsonArray(value: TArray) {
if (value["!stringify"]) {
value["!stringify"](value, ctx);
return;
}
buffer.writeString("[");
buffer.linefeed();
buffer.indent();
for (let i = 0; i < value.length; i++) {
const v = value[i];
buffer.padding();
writeJsonValue(v);
if (i < value.length - 1) {
buffer.writeString(",");
}
buffer.linefeed();
}
buffer.unindent();
buffer.padding();
buffer.writeString("]");
}
writeJsonValue(data as TValue);
return buffer.toString();
};
src/misc/util.ts
+5 -1
View File
@@ -4,6 +4,7 @@ import { type WorkspaceModel } from "../contexts/workspace-context";
import { VERSION, type TreeData } from "./b3type";
import { dfs } from "./b3util";
import Path from "./path";
import { stringifyJson } from "./stringify";
export const nanoid = customAlphabet(
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
@@ -16,7 +17,7 @@ export const readJson = <T>(path: string): T => {
};
export const writeJson = <T>(path: string, data: T) => {
const str = JSON.stringify(data, undefined, 2);
const str = stringifyJson(data, { indent: 2 });
fs.writeFileSync(path, str, "utf-8");
};
@@ -34,6 +35,8 @@ export const readTree = (path: string) => {
data.import = data.import || [];
data.vars = data.vars || [];
data.root = data.root || {};
data.$override = data.$override || {};
data.custom = data.custom || {};
// compatible with old version
dfs(data.root, (node) => {
@@ -57,6 +60,7 @@ export const writeTree = (path: string, data: TreeData) => {
import: data.import,
vars: data.vars,
root: data.root,
custom: data.custom,
$override: data.$override,
});
};