Skip to content

Commit 3290b66

Browse files
Alive24Alive24
committed
fix: second revision on for ckb-devrel#210 
1 parent 247804e commit 3290b66

2 files changed

Lines changed: 66 additions & 53 deletions

File tree

‎packages/molecule/src/codec.ts‎

Lines changed: 42 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ function toCodec(
3434
if (outputCodecRecord[molTypeDefinition.name]) {
3535
return outputCodecRecord[molTypeDefinition.name];
3636
}
37-
let codec: mol.Codec<any, any> | null = null;
37+
let codec: mol.Codec<any, any> | undefined = undefined;
3838
switch (molTypeDefinition.type) {
3939
case "array": {
4040
const builtInCodec =
@@ -96,26 +96,24 @@ function toCodec(
9696
molTypeDefinition.items.forEach((unionTypeItem, index) => {
9797
if (unionTypeItem === BYTE) {
9898
unionCodecs.push([unionTypeItem, index, mol.Byte]);
99-
} else {
100-
if (typeof unionTypeItem === "string") {
101-
const itemCodec = outputCodecRecord[unionTypeItem];
102-
if (!itemCodec) {
103-
throw new Error(
104-
`Codec not found for item type: ${unionTypeItem} in union type: ${molTypeDefinition.name}`,
105-
);
106-
}
107-
unionCodecs.push([unionTypeItem, index, itemCodec]);
108-
} else if (Array.isArray(unionTypeItem)) {
109-
const [key, fieldId] = unionTypeItem;
99+
} else if (typeof unionTypeItem === "string") {
100+
const itemCodec = outputCodecRecord[unionTypeItem];
101+
if (!itemCodec) {
102+
throw new Error(
103+
`Codec not found for item type: ${unionTypeItem} in union type: ${molTypeDefinition.name}`,
104+
);
105+
}
106+
unionCodecs.push([unionTypeItem, index, itemCodec]);
107+
} else if (Array.isArray(unionTypeItem)) {
108+
const [key, fieldId] = unionTypeItem;
110109

111-
const itemCodec = outputCodecRecord[key];
112-
if (!itemCodec) {
113-
throw new Error(
114-
`Codec not found for item type: ${key} in union type: ${molTypeDefinition.name}`,
115-
);
116-
}
117-
unionCodecs.push([key, fieldId, itemCodec]);
110+
const itemCodec = key == "byte" ? mol.Byte : outputCodecRecord[key];
111+
if (!itemCodec) {
112+
throw new Error(
113+
`Codec not found for item type: ${key} in union type: ${molTypeDefinition.name}`,
114+
);
118115
}
116+
unionCodecs.push([key, fieldId, itemCodec]);
119117
}
120118
});
121119

@@ -197,29 +195,46 @@ export function toCodecRecord(
197195
molTypeDefinitions: MolTypeDefinition[],
198196
extraReferences?: CodecRecord,
199197
): CodecRecord {
200-
const outputCodecRecord: CodecRecord = extraReferences || {};
198+
const outputCodecRecord: CodecRecord = extraReferences ?? {};
201199
const processed = new Set<string>();
202200

203201
function process(definition: MolTypeDefinition) {
204-
if (processed.has(definition.name)) return;
202+
if (processed.has(definition.name)) {
203+
return;
204+
}
205205

206206
// Process dependencies based on type
207207
if ("item" in definition && definition.item !== BYTE) {
208-
const dep = molTypeDefinitions.find((d) => d.name === definition.item);
209-
if (dep) process(dep);
208+
const dependency = molTypeDefinitions.find(
209+
(currentMolTypeDefinition) =>
210+
currentMolTypeDefinition.name === definition.item,
211+
);
212+
if (dependency) {
213+
process(dependency);
214+
}
210215
} else if ("fields" in definition) {
211216
definition.fields.forEach((field) => {
212217
if (field.type !== BYTE) {
213-
const dep = molTypeDefinitions.find((d) => d.name === field.type);
214-
if (dep) process(dep);
218+
const dependency = molTypeDefinitions.find(
219+
(currentMolTypeDefinition) =>
220+
currentMolTypeDefinition.name === field.type,
221+
);
222+
if (dependency) {
223+
process(dependency);
224+
}
215225
}
216226
});
217227
} else if (definition.type === "union") {
218228
definition.items.forEach((item) => {
219229
const name = typeof item === "string" ? item : item[0];
220230
if (name !== BYTE) {
221-
const dep = molTypeDefinitions.find((d) => d.name === name);
222-
if (dep) process(dep);
231+
const dependency = molTypeDefinitions.find(
232+
(currentMolTypeDefinition) =>
233+
currentMolTypeDefinition.name === name,
234+
);
235+
if (dependency) {
236+
process(dependency);
237+
}
223238
}
224239
});
225240
}

‎packages/molecule/src/utils.ts‎

Lines changed: 24 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -112,21 +112,21 @@ export function validateMolTypeDefinitions(
112112
}
113113
case "union": {
114114
const unionDeps = molTypeDefinition.items;
115-
unionDeps.forEach((dep) => {
116-
if (typeof dep === "string" && dep !== BYTE) {
115+
unionDeps.forEach((dependency) => {
116+
if (typeof dependency === "string" && dependency !== BYTE) {
117117
if (
118118
!molTypeDefinitions.find(
119-
(molTypeDefinition) => molTypeDefinition.name === dep,
119+
(molTypeDefinition) => molTypeDefinition.name === dependency,
120120
) &&
121-
!(extraReferences && dep in extraReferences)
121+
!(extraReferences && dependency in extraReferences)
122122
) {
123123
throw new Error(
124-
`Dependency ${dep} not found for union type ${molTypeDefinition.name}`,
124+
`Dependency ${dependency} not found for union type ${molTypeDefinition.name}`,
125125
);
126126
}
127127
}
128-
if (Array.isArray(dep)) {
129-
const [key, id] = dep;
128+
if (Array.isArray(dependency)) {
129+
const [key, id] = dependency;
130130
// check if the id is a valid uint32
131131
mol.Uint32.encode(id);
132132
if (
@@ -147,16 +147,16 @@ export function validateMolTypeDefinitions(
147147
const tableDeps = molTypeDefinition.fields.map(
148148
(field: Field) => field.type,
149149
);
150-
tableDeps.forEach((dep: string) => {
151-
if (dep !== BYTE) {
150+
tableDeps.forEach((dependency: string) => {
151+
if (dependency !== BYTE) {
152152
if (
153153
!molTypeDefinitions.find(
154-
(molTypeDefinition) => molTypeDefinition.name === dep,
154+
(molTypeDefinition) => molTypeDefinition.name === dependency,
155155
) &&
156-
!(extraReferences && dep in extraReferences)
156+
!(extraReferences && dependency in extraReferences)
157157
) {
158158
throw new Error(
159-
`Dependency ${dep} not found for table type ${molTypeDefinition.name}`,
159+
`Dependency ${dependency} not found for table type ${molTypeDefinition.name}`,
160160
);
161161
}
162162
}
@@ -185,22 +185,21 @@ export function validateMolTypeDefinitions(
185185
* - If a field is not BYTE, its type must be a fixed-length type
186186
*
187187
* @param molTypeDefinition - The molecule type definition to validate
188-
* @param molTypeDefinitionsAsReferences - Available type definitions that can be referenced
188+
* @param molTypeDefinitions - Available type definitions that can be referenced
189189
* @throws Error if the type is not fixed length or if required dependencies are not found
190190
*/
191191
function assertFixedLengthMolType(
192192
molTypeDefinition: MolTypeDefinition,
193-
molTypeDefinitionsAsReferences: MolTypeDefinition[],
193+
molTypeDefinitions: MolTypeDefinition[],
194194
extraReferences?: CodecRecord,
195195
): void {
196196
switch (molTypeDefinition.type) {
197197
case "array": {
198198
if (molTypeDefinition.item !== BYTE) {
199-
const matchingItemMolTypeDefinition =
200-
molTypeDefinitionsAsReferences.find(
201-
(molTypeDefinitionAsReference) =>
202-
molTypeDefinitionAsReference.name === molTypeDefinition.item,
203-
);
199+
const matchingItemMolTypeDefinition = molTypeDefinitions.find(
200+
(singleMolTypeDefinition) =>
201+
singleMolTypeDefinition.name === molTypeDefinition.item,
202+
);
204203
if (!matchingItemMolTypeDefinition) {
205204
const matchingExtraReference =
206205
extraReferences?.[molTypeDefinition.item];
@@ -216,7 +215,7 @@ function assertFixedLengthMolType(
216215
} else {
217216
assertFixedLengthMolType(
218217
matchingItemMolTypeDefinition,
219-
molTypeDefinitionsAsReferences,
218+
molTypeDefinitions,
220219
extraReferences,
221220
);
222221
}
@@ -227,11 +226,10 @@ function assertFixedLengthMolType(
227226
const fields = molTypeDefinition.fields;
228227
fields.forEach((field: Field) => {
229228
if (field.type !== BYTE) {
230-
const matchingFieldMolTypeDefinition =
231-
molTypeDefinitionsAsReferences.find(
232-
(molTypeDefinitionAsReference) =>
233-
molTypeDefinitionAsReference.name === field.type,
234-
);
229+
const matchingFieldMolTypeDefinition = molTypeDefinitions.find(
230+
(currentMolTypeDefinition) =>
231+
currentMolTypeDefinition.name === field.type,
232+
);
235233
if (!matchingFieldMolTypeDefinition) {
236234
const matchingExtraReference = extraReferences?.[field.type];
237235
if (!matchingExtraReference) {
@@ -246,7 +244,7 @@ function assertFixedLengthMolType(
246244
} else {
247245
assertFixedLengthMolType(
248246
matchingFieldMolTypeDefinition,
249-
molTypeDefinitionsAsReferences,
247+
molTypeDefinitions,
250248
extraReferences,
251249
);
252250
}

0 commit comments

Comments
 (0)