mirror of
https://github.com/JamesIves/github-pages-deploy-action.git
synced 2023-12-15 20:03:39 +08:00
184 lines
6.0 KiB
JavaScript
184 lines
6.0 KiB
JavaScript
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
import objectValues from "../polyfills/objectValues.mjs";
|
|
import inspect from "../jsutils/inspect.mjs";
|
|
import invariant from "../jsutils/invariant.mjs";
|
|
import keyValMap from "../jsutils/keyValMap.mjs";
|
|
import { GraphQLSchema } from "../type/schema.mjs";
|
|
import { GraphQLDirective } from "../type/directives.mjs";
|
|
import { isIntrospectionType } from "../type/introspection.mjs";
|
|
import { GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, isListType, isNonNullType, isScalarType, isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType } from "../type/definition.mjs";
|
|
/**
|
|
* Sort GraphQLSchema.
|
|
*
|
|
* This function returns a sorted copy of the given GraphQLSchema.
|
|
*/
|
|
|
|
export function lexicographicSortSchema(schema) {
|
|
var schemaConfig = schema.toConfig();
|
|
var typeMap = keyValMap(sortByName(schemaConfig.types), function (type) {
|
|
return type.name;
|
|
}, sortNamedType);
|
|
return new GraphQLSchema(_objectSpread({}, schemaConfig, {
|
|
types: objectValues(typeMap),
|
|
directives: sortByName(schemaConfig.directives).map(sortDirective),
|
|
query: replaceMaybeType(schemaConfig.query),
|
|
mutation: replaceMaybeType(schemaConfig.mutation),
|
|
subscription: replaceMaybeType(schemaConfig.subscription)
|
|
}));
|
|
|
|
function replaceType(type) {
|
|
if (isListType(type)) {
|
|
return new GraphQLList(replaceType(type.ofType));
|
|
} else if (isNonNullType(type)) {
|
|
return new GraphQLNonNull(replaceType(type.ofType));
|
|
}
|
|
|
|
return replaceNamedType(type);
|
|
}
|
|
|
|
function replaceNamedType(type) {
|
|
return typeMap[type.name];
|
|
}
|
|
|
|
function replaceMaybeType(maybeType) {
|
|
return maybeType && replaceNamedType(maybeType);
|
|
}
|
|
|
|
function sortDirective(directive) {
|
|
var config = directive.toConfig();
|
|
return new GraphQLDirective(_objectSpread({}, config, {
|
|
locations: sortBy(config.locations, function (x) {
|
|
return x;
|
|
}),
|
|
args: sortArgs(config.args)
|
|
}));
|
|
}
|
|
|
|
function sortArgs(args) {
|
|
return sortObjMap(args, function (arg) {
|
|
return _objectSpread({}, arg, {
|
|
type: replaceType(arg.type)
|
|
});
|
|
});
|
|
}
|
|
|
|
function sortFields(fieldsMap) {
|
|
return sortObjMap(fieldsMap, function (field) {
|
|
return _objectSpread({}, field, {
|
|
type: replaceType(field.type),
|
|
args: sortArgs(field.args)
|
|
});
|
|
});
|
|
}
|
|
|
|
function sortInputFields(fieldsMap) {
|
|
return sortObjMap(fieldsMap, function (field) {
|
|
return _objectSpread({}, field, {
|
|
type: replaceType(field.type)
|
|
});
|
|
});
|
|
}
|
|
|
|
function sortTypes(arr) {
|
|
return sortByName(arr).map(replaceNamedType);
|
|
}
|
|
|
|
function sortNamedType(type) {
|
|
if (isScalarType(type) || isIntrospectionType(type)) {
|
|
return type;
|
|
}
|
|
|
|
if (isObjectType(type)) {
|
|
var config = type.toConfig();
|
|
return new GraphQLObjectType(_objectSpread({}, config, {
|
|
interfaces: function interfaces() {
|
|
return sortTypes(config.interfaces);
|
|
},
|
|
fields: function fields() {
|
|
return sortFields(config.fields);
|
|
}
|
|
}));
|
|
}
|
|
|
|
if (isInterfaceType(type)) {
|
|
var _config = type.toConfig();
|
|
|
|
return new GraphQLInterfaceType(_objectSpread({}, _config, {
|
|
interfaces: function interfaces() {
|
|
return sortTypes(_config.interfaces);
|
|
},
|
|
fields: function fields() {
|
|
return sortFields(_config.fields);
|
|
}
|
|
}));
|
|
}
|
|
|
|
if (isUnionType(type)) {
|
|
var _config2 = type.toConfig();
|
|
|
|
return new GraphQLUnionType(_objectSpread({}, _config2, {
|
|
types: function types() {
|
|
return sortTypes(_config2.types);
|
|
}
|
|
}));
|
|
}
|
|
|
|
if (isEnumType(type)) {
|
|
var _config3 = type.toConfig();
|
|
|
|
return new GraphQLEnumType(_objectSpread({}, _config3, {
|
|
values: sortObjMap(_config3.values)
|
|
}));
|
|
}
|
|
|
|
/* istanbul ignore else */
|
|
if (isInputObjectType(type)) {
|
|
var _config4 = type.toConfig();
|
|
|
|
return new GraphQLInputObjectType(_objectSpread({}, _config4, {
|
|
fields: function fields() {
|
|
return sortInputFields(_config4.fields);
|
|
}
|
|
}));
|
|
} // Not reachable. All possible types have been considered.
|
|
|
|
|
|
/* istanbul ignore next */
|
|
invariant(false, 'Unexpected type: ' + inspect(type));
|
|
}
|
|
}
|
|
|
|
function sortObjMap(map, sortValueFn) {
|
|
var sortedMap = Object.create(null);
|
|
var sortedKeys = sortBy(Object.keys(map), function (x) {
|
|
return x;
|
|
});
|
|
|
|
for (var _i2 = 0; _i2 < sortedKeys.length; _i2++) {
|
|
var key = sortedKeys[_i2];
|
|
var value = map[key];
|
|
sortedMap[key] = sortValueFn ? sortValueFn(value) : value;
|
|
}
|
|
|
|
return sortedMap;
|
|
}
|
|
|
|
function sortByName(array) {
|
|
return sortBy(array, function (obj) {
|
|
return obj.name;
|
|
});
|
|
}
|
|
|
|
function sortBy(array, mapToKey) {
|
|
return array.slice().sort(function (obj1, obj2) {
|
|
var key1 = mapToKey(obj1);
|
|
var key2 = mapToKey(obj2);
|
|
return key1.localeCompare(key2);
|
|
});
|
|
}
|