@0no-co/graphql.web 0.1.0 → 0.1.2

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 0no.co
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/graphql.web.d.ts

@@ -0,0 +1,250 @@
+declare enum Kind {
+    /** Name */
+    NAME = "Name",
+    /** Document */
+    DOCUMENT = "Document",
+    OPERATION_DEFINITION = "OperationDefinition",
+    VARIABLE_DEFINITION = "VariableDefinition",
+    SELECTION_SET = "SelectionSet",
+    FIELD = "Field",
+    ARGUMENT = "Argument",
+    /** Fragments */
+    FRAGMENT_SPREAD = "FragmentSpread",
+    INLINE_FRAGMENT = "InlineFragment",
+    FRAGMENT_DEFINITION = "FragmentDefinition",
+    /** Values */
+    VARIABLE = "Variable",
+    INT = "IntValue",
+    FLOAT = "FloatValue",
+    STRING = "StringValue",
+    BOOLEAN = "BooleanValue",
+    NULL = "NullValue",
+    ENUM = "EnumValue",
+    LIST = "ListValue",
+    OBJECT = "ObjectValue",
+    OBJECT_FIELD = "ObjectField",
+    /** Directives */
+    DIRECTIVE = "Directive",
+    /** Types */
+    NAMED_TYPE = "NamedType",
+    LIST_TYPE = "ListType",
+    NON_NULL_TYPE = "NonNullType"
+}
+
+interface Location {
+    readonly start: number;
+    readonly end: number;
+    readonly source: Source;
+}
+interface Source {
+    body: string;
+    name: string;
+    locationOffset: {
+        line: number;
+        column: number;
+    };
+}
+declare type ASTNode = NameNode | DocumentNode | OperationDefinitionNode | VariableDefinitionNode | VariableNode | SelectionSetNode | FieldNode | ArgumentNode | FragmentSpreadNode | InlineFragmentNode | FragmentDefinitionNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode | ObjectFieldNode | DirectiveNode | NamedTypeNode | ListTypeNode | NonNullTypeNode;
+interface NameNode {
+    readonly kind: Kind.NAME;
+    readonly value: string;
+}
+interface DocumentNode {
+    readonly kind: Kind.DOCUMENT;
+    readonly definitions: ReadonlyArray<ExecutableDefinitionNode>;
+    readonly loc?: Location;
+}
+type DefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
+type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
+interface OperationDefinitionNode {
+    readonly kind: Kind.OPERATION_DEFINITION;
+    readonly operation: OperationTypeNode;
+    readonly name?: NameNode;
+    readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly selectionSet: SelectionSetNode;
+}
+declare const enum OperationTypeNode {
+    QUERY = "query",
+    MUTATION = "mutation",
+    SUBSCRIPTION = "subscription"
+}
+interface VariableDefinitionNode {
+    readonly kind: Kind.VARIABLE_DEFINITION;
+    readonly variable: VariableNode;
+    readonly type: TypeNode;
+    readonly defaultValue?: ConstValueNode;
+    readonly directives?: ReadonlyArray<ConstDirectiveNode>;
+}
+interface VariableNode {
+    readonly kind: Kind.VARIABLE;
+    readonly name: NameNode;
+}
+interface SelectionSetNode {
+    kind: Kind.SELECTION_SET;
+    selections: ReadonlyArray<SelectionNode>;
+}
+declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
+interface FieldNode {
+    readonly kind: Kind.FIELD;
+    readonly alias?: NameNode;
+    readonly name: NameNode;
+    readonly arguments?: ReadonlyArray<ArgumentNode>;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly selectionSet?: SelectionSetNode;
+}
+interface ArgumentNode {
+    readonly kind: Kind.ARGUMENT;
+    readonly name: NameNode;
+    readonly value: ValueNode;
+}
+interface ConstArgumentNode {
+    readonly kind: Kind.ARGUMENT;
+    readonly name: NameNode;
+    readonly value: ConstValueNode;
+}
+interface FragmentSpreadNode {
+    readonly kind: Kind.FRAGMENT_SPREAD;
+    readonly name: NameNode;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+}
+interface InlineFragmentNode {
+    readonly kind: Kind.INLINE_FRAGMENT;
+    readonly typeCondition?: NamedTypeNode;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly selectionSet: SelectionSetNode;
+}
+interface FragmentDefinitionNode {
+    readonly kind: Kind.FRAGMENT_DEFINITION;
+    readonly name: NameNode;
+    readonly typeCondition: NamedTypeNode;
+    readonly directives?: ReadonlyArray<DirectiveNode>;
+    readonly selectionSet: SelectionSetNode;
+}
+type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
+type ConstValueNode = IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ConstListValueNode | ConstObjectValueNode;
+interface IntValueNode {
+    readonly kind: Kind.INT;
+    readonly value: string;
+}
+interface FloatValueNode {
+    readonly kind: Kind.FLOAT;
+    readonly value: string;
+}
+interface StringValueNode {
+    readonly kind: Kind.STRING;
+    readonly value: string;
+    readonly block?: boolean;
+}
+interface BooleanValueNode {
+    readonly kind: Kind.BOOLEAN;
+    readonly value: boolean;
+}
+interface NullValueNode {
+    readonly kind: Kind.NULL;
+}
+interface EnumValueNode {
+    readonly kind: Kind.ENUM;
+    readonly value: string;
+}
+interface ListValueNode {
+    readonly kind: Kind.LIST;
+    readonly values: ReadonlyArray<ValueNode>;
+}
+interface ConstListValueNode {
+    readonly kind: Kind.LIST;
+    readonly values: ReadonlyArray<ConstValueNode>;
+}
+interface ObjectValueNode {
+    readonly kind: Kind.OBJECT;
+    readonly fields: ReadonlyArray<ObjectFieldNode>;
+}
+interface ConstObjectValueNode {
+    readonly kind: Kind.OBJECT;
+    readonly fields: ReadonlyArray<ConstObjectFieldNode>;
+}
+interface ObjectFieldNode {
+    readonly kind: Kind.OBJECT_FIELD;
+    readonly name: NameNode;
+    readonly value: ValueNode;
+}
+interface ConstObjectFieldNode {
+    readonly kind: Kind.OBJECT_FIELD;
+    readonly name: NameNode;
+    readonly value: ConstValueNode;
+}
+interface DirectiveNode {
+    readonly kind: Kind.DIRECTIVE;
+    readonly name: NameNode;
+    readonly arguments?: ReadonlyArray<ArgumentNode>;
+}
+interface ConstDirectiveNode {
+    readonly kind: Kind.DIRECTIVE;
+    readonly name: NameNode;
+    readonly arguments?: ReadonlyArray<ConstArgumentNode>;
+}
+declare type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
+interface NamedTypeNode {
+    readonly kind: Kind.NAMED_TYPE;
+    readonly name: NameNode;
+}
+interface ListTypeNode {
+    readonly kind: Kind.LIST_TYPE;
+    readonly type: TypeNode;
+}
+interface NonNullTypeNode {
+    readonly kind: Kind.NON_NULL_TYPE;
+    readonly type: NamedTypeNode | ListTypeNode;
+}
+
+type Maybe<T> = T | undefined | null;
+interface Extensions {
+    [extension: string]: unknown;
+}
+
+declare class GraphQLError extends Error {
+    readonly locations: undefined;
+    readonly path: ReadonlyArray<string | number> | undefined;
+    readonly nodes: ReadonlyArray<ASTNode> | undefined;
+    readonly source: Source | undefined;
+    readonly positions: ReadonlyArray<number> | undefined;
+    readonly originalError: Error | undefined;
+    readonly extensions: Extensions;
+    constructor(message: string, nodes?: ReadonlyArray<ASTNode> | ASTNode | null, source?: Maybe<Source>, positions?: Maybe<ReadonlyArray<number>>, path?: Maybe<ReadonlyArray<string | number>>, originalError?: Maybe<Error>, extensions?: Maybe<Extensions>);
+    toJSON(): this;
+    toString(): string;
+}
+
+declare function blockString(string: string): string;
+declare function parse(string: string): DocumentNode;
+declare function parseValue(string: string): ValueNode | undefined;
+declare function parseType(string: string): TypeNode | undefined;
+
+declare const BREAK: {};
+declare function visit<N extends ASTNode>(root: N, visitor: ASTVisitor): N;
+declare function visit<R>(root: ASTNode, visitor: ASTReducer<R>): R;
+type ASTVisitor = EnterLeaveVisitor<ASTNode> | KindVisitor;
+type KindVisitor = {
+    readonly [NodeT in ASTNode as NodeT['kind']]?: ASTVisitFn<NodeT> | EnterLeaveVisitor<NodeT>;
+};
+interface EnterLeaveVisitor<TVisitedNode extends ASTNode> {
+    readonly enter?: ASTVisitFn<TVisitedNode> | undefined;
+    readonly leave?: ASTVisitFn<TVisitedNode> | undefined;
+}
+type ASTVisitFn<Node extends ASTNode> = (node: Node, key: string | number | undefined, parent: ASTNode | ReadonlyArray<ASTNode> | undefined, path: ReadonlyArray<string | number>, ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => any;
+type ASTReducer<R> = {
+    readonly [NodeT in ASTNode as NodeT['kind']]?: {
+        readonly enter?: ASTVisitFn<NodeT>;
+        readonly leave: ASTReducerFn<NodeT, R>;
+    };
+};
+type ASTReducerFn<TReducedNode extends ASTNode, R> = (node: {
+    [K in keyof TReducedNode]: ReducedField<TReducedNode[K], R>;
+}, key: string | number | undefined, parent: ASTNode | ReadonlyArray<ASTNode> | undefined, path: ReadonlyArray<string | number>, ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>) => R;
+type ReducedField<T, R> = T extends null | undefined ? T : T extends ReadonlyArray<any> ? ReadonlyArray<R> : R;
+
+declare function printString(string: string): string;
+declare function printBlockString(string: string): string;
+declare function print(node: ASTNode): string;
+
+export { ASTNode, ASTReducer, ASTVisitFn, ASTVisitor, ArgumentNode, BREAK, BooleanValueNode, ConstArgumentNode, ConstDirectiveNode, ConstListValueNode, ConstObjectFieldNode, ConstObjectValueNode, ConstValueNode, DefinitionNode, DirectiveNode, DocumentNode, EnumValueNode, ExecutableDefinitionNode, FieldNode, FloatValueNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, IntValueNode, Kind, ListTypeNode, ListValueNode, Location, NameNode, NamedTypeNode, NonNullTypeNode, NullValueNode, ObjectFieldNode, ObjectValueNode, OperationDefinitionNode, OperationTypeNode, SelectionNode, SelectionSetNode, Source, StringValueNode, TypeNode, ValueNode, VariableDefinitionNode, VariableNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, visit };