@backland/schema
Version:
TypeScript schema declaration and validation library with static type inference
131 lines • 5.23 kB
JavaScript
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
import { awaitSync, describeType, ensureArray, noop, proxyRealValue } from '@backland/utils';
import { GraphType } from '../GraphType/GraphType';
import { ObjectType } from '../ObjectType';
import { isFieldTypeName } from '../fields/fieldTypes';
import { createTSfyRef, getTSFyIdentifier } from './tsfy';
export function parseTSFyValue(_x, _x2) {
return _parseTSFyValue.apply(this, arguments);
}
function _parseTSFyValue() {
_parseTSFyValue = _asyncToGenerator(function* (rootValue, context) {
rootValue = proxyRealValue(rootValue);
//
var typeDescription = describeType(rootValue);
var identifier = getTSFyIdentifier(rootValue);
var hash = typeDescription.hash();
var existing = context.refs[hash];
var currentRef = createTSfyRef(hash, identifier);
if (existing !== undefined) {
existing.count++;
} else {
context.refs[hash] = currentRef;
}
if (context.config.customParser) {
var parsed = yield context.config.customParser({
context,
typeDescription,
hash,
identifier,
existing,
currentRef,
value: rootValue
});
if (parsed !== undefined) return parsed;
}
var {
typename,
native
} = typeDescription;
if (native && typename !== 'Object') {
var body = typeDescription.toString();
currentRef.result = body;
return currentRef;
}
if (ObjectType.is(rootValue)) {
var child = yield parseTSFyValue(rootValue.definition, context);
currentRef.parts = ['ObjectType<', ...ensureArray(child), '>'];
return currentRef;
}
if (GraphType.is(rootValue)) {
var _child = yield parseTSFyValue(rootValue.definition, context);
currentRef.parts = ['GraphType<', ...ensureArray(_child), '>'];
return currentRef;
}
yield _asyncToGenerator(function* () {
switch (typename) {
case 'Function':
{
context.header[hash] = 'export type AnyFunction = (...args: any[]) => any; ';
currentRef.result = 'AnyFunction';
return currentRef;
}
case 'Array':
{
if (!Array.isArray(rootValue)) throw noop;
if (!rootValue.length) {
currentRef.result = '[]';
return currentRef;
}
var lastIndex = rootValue.length - 1;
var _child2 = yield awaitSync(rootValue.map( /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(function* (element, index) {
var part = yield parseTSFyValue(element, context);
var res = ensureArray(part);
if (index !== lastIndex) return [...res, ', '];
return res;
});
return function (_x3, _x4) {
return _ref2.apply(this, arguments);
};
}()));
currentRef.parts = ['[', ...ensureArray(_child2), ']'];
return currentRef;
}
case 'Object':
{
var pairs = Object.entries(rootValue);
if (!pairs.length) {
currentRef.result = '{}';
return currentRef;
}
currentRef.parts.push('{');
yield awaitSync(pairs.map( /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator(function* (_ref3) {
var [key, value] = _ref3;
if (key === '__dschm__') return;
if ((value === null || value === void 0 ? void 0 : value.hidden) === true && isFieldTypeName(value.type)) {
return;
}
var valueRes = yield parseTSFyValue(value, context);
currentRef.parts.push("".concat(JSON.stringify(key), ":"), valueRes, ',');
});
return function (_x5) {
return _ref4.apply(this, arguments);
};
}()));
currentRef.parts.push('}');
return currentRef;
}
default:
{
var described = describeType(rootValue);
var {
native: _native,
typename: _typename
} = described;
if (!_native) {
currentRef.result = "any /*".concat(_typename, "*/");
} else {
currentRef.result = _typename;
}
return currentRef;
}
}
})();
return currentRef;
});
return _parseTSFyValue.apply(this, arguments);
}
//# sourceMappingURL=parseTSFyValue.js.map