slidge-whatsapp 0.2.6__cp312-cp312-manylinux_2_36_aarch64.whl → 0.3.0__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/decode.go

@@ -0,0 +1,216 @@
+package ast
+
+import (
+	"encoding/json"
+)
+
+func UnmarshalSelectionSet(b []byte) (SelectionSet, error) {
+	var tmp []json.RawMessage
+
+	if err := json.Unmarshal(b, &tmp); err != nil {
+		return nil, err
+	}
+
+	result := make([]Selection, 0)
+	for _, item := range tmp {
+		var field Field
+		if err := json.Unmarshal(item, &field); err == nil {
+			result = append(result, &field)
+			continue
+		}
+		var fragmentSpread FragmentSpread
+		if err := json.Unmarshal(item, &fragmentSpread); err == nil {
+			result = append(result, &fragmentSpread)
+			continue
+		}
+		var inlineFragment InlineFragment
+		if err := json.Unmarshal(item, &inlineFragment); err == nil {
+			result = append(result, &inlineFragment)
+			continue
+		}
+	}
+
+	return result, nil
+}
+
+func (f *FragmentDefinition) UnmarshalJSON(b []byte) error {
+	var tmp map[string]json.RawMessage
+	if err := json.Unmarshal(b, &tmp); err != nil {
+		return err
+	}
+	for k := range tmp {
+		switch k {
+		case "Name":
+			err := json.Unmarshal(tmp[k], &f.Name)
+			if err != nil {
+				return err
+			}
+		case "VariableDefinition":
+			err := json.Unmarshal(tmp[k], &f.VariableDefinition)
+			if err != nil {
+				return err
+			}
+		case "TypeCondition":
+			err := json.Unmarshal(tmp[k], &f.TypeCondition)
+			if err != nil {
+				return err
+			}
+		case "Directives":
+			err := json.Unmarshal(tmp[k], &f.Directives)
+			if err != nil {
+				return err
+			}
+		case "SelectionSet":
+			ss, err := UnmarshalSelectionSet(tmp[k])
+			if err != nil {
+				return err
+			}
+			f.SelectionSet = ss
+		case "Definition":
+			err := json.Unmarshal(tmp[k], &f.Definition)
+			if err != nil {
+				return err
+			}
+		case "Position":
+			err := json.Unmarshal(tmp[k], &f.Position)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (f *InlineFragment) UnmarshalJSON(b []byte) error {
+	var tmp map[string]json.RawMessage
+	if err := json.Unmarshal(b, &tmp); err != nil {
+		return err
+	}
+	for k := range tmp {
+		switch k {
+		case "TypeCondition":
+			err := json.Unmarshal(tmp[k], &f.TypeCondition)
+			if err != nil {
+				return err
+			}
+		case "Directives":
+			err := json.Unmarshal(tmp[k], &f.Directives)
+			if err != nil {
+				return err
+			}
+		case "SelectionSet":
+			ss, err := UnmarshalSelectionSet(tmp[k])
+			if err != nil {
+				return err
+			}
+			f.SelectionSet = ss
+		case "ObjectDefinition":
+			err := json.Unmarshal(tmp[k], &f.ObjectDefinition)
+			if err != nil {
+				return err
+			}
+		case "Position":
+			err := json.Unmarshal(tmp[k], &f.Position)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (f *OperationDefinition) UnmarshalJSON(b []byte) error {
+	var tmp map[string]json.RawMessage
+	if err := json.Unmarshal(b, &tmp); err != nil {
+		return err
+	}
+	for k := range tmp {
+		switch k {
+		case "Operation":
+			err := json.Unmarshal(tmp[k], &f.Operation)
+			if err != nil {
+				return err
+			}
+		case "Name":
+			err := json.Unmarshal(tmp[k], &f.Name)
+			if err != nil {
+				return err
+			}
+		case "VariableDefinitions":
+			err := json.Unmarshal(tmp[k], &f.VariableDefinitions)
+			if err != nil {
+				return err
+			}
+		case "Directives":
+			err := json.Unmarshal(tmp[k], &f.Directives)
+			if err != nil {
+				return err
+			}
+		case "SelectionSet":
+			ss, err := UnmarshalSelectionSet(tmp[k])
+			if err != nil {
+				return err
+			}
+			f.SelectionSet = ss
+		case "Position":
+			err := json.Unmarshal(tmp[k], &f.Position)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (f *Field) UnmarshalJSON(b []byte) error {
+	var tmp map[string]json.RawMessage
+	if err := json.Unmarshal(b, &tmp); err != nil {
+		return err
+	}
+	for k := range tmp {
+		switch k {
+		case "Alias":
+			err := json.Unmarshal(tmp[k], &f.Alias)
+			if err != nil {
+				return err
+			}
+		case "Name":
+			err := json.Unmarshal(tmp[k], &f.Name)
+			if err != nil {
+				return err
+			}
+		case "Arguments":
+			err := json.Unmarshal(tmp[k], &f.Arguments)
+			if err != nil {
+				return err
+			}
+		case "Directives":
+			err := json.Unmarshal(tmp[k], &f.Directives)
+			if err != nil {
+				return err
+			}
+		case "SelectionSet":
+			ss, err := UnmarshalSelectionSet(tmp[k])
+			if err != nil {
+				return err
+			}
+			f.SelectionSet = ss
+		case "Position":
+			err := json.Unmarshal(tmp[k], &f.Position)
+			if err != nil {
+				return err
+			}
+		case "Definition":
+			err := json.Unmarshal(tmp[k], &f.Definition)
+			if err != nil {
+				return err
+			}
+		case "ObjectDefinition":
+			err := json.Unmarshal(tmp[k], &f.ObjectDefinition)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/definition.go

@@ -0,0 +1,110 @@
+package ast
+
+type DefinitionKind string
+
+const (
+	Scalar      DefinitionKind = "SCALAR"
+	Object      DefinitionKind = "OBJECT"
+	Interface   DefinitionKind = "INTERFACE"
+	Union       DefinitionKind = "UNION"
+	Enum        DefinitionKind = "ENUM"
+	InputObject DefinitionKind = "INPUT_OBJECT"
+)
+
+// Definition is the core type definition object, it includes all of the definable types
+// but does *not* cover schema or directives.
+//
+// @vektah: Javascript implementation has different types for all of these, but they are
+// more similar than different and don't define any behaviour. I think this style of
+// "some hot" struct works better, at least for go.
+//
+// Type extensions are also represented by this same struct.
+type Definition struct {
+	Kind        DefinitionKind
+	Description string
+	Name        string
+	Directives  DirectiveList
+	Interfaces  []string      // object and input object
+	Fields      FieldList     // object and input object
+	Types       []string      // union
+	EnumValues  EnumValueList // enum
+
+	Position *Position `dump:"-" json:"-"`
+	BuiltIn  bool      `dump:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+	EndOfDefinitionComment   *CommentGroup
+}
+
+func (d *Definition) IsLeafType() bool {
+	return d.Kind == Enum || d.Kind == Scalar
+}
+
+func (d *Definition) IsAbstractType() bool {
+	return d.Kind == Interface || d.Kind == Union
+}
+
+func (d *Definition) IsCompositeType() bool {
+	return d.Kind == Object || d.Kind == Interface || d.Kind == Union
+}
+
+func (d *Definition) IsInputType() bool {
+	return d.Kind == Scalar || d.Kind == Enum || d.Kind == InputObject
+}
+
+func (d *Definition) OneOf(types ...string) bool {
+	for _, t := range types {
+		if d.Name == t {
+			return true
+		}
+	}
+	return false
+}
+
+type FieldDefinition struct {
+	Description  string
+	Name         string
+	Arguments    ArgumentDefinitionList // only for objects
+	DefaultValue *Value                 // only for input objects
+	Type         *Type
+	Directives   DirectiveList
+	Position     *Position `dump:"-" json:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+}
+
+type ArgumentDefinition struct {
+	Description  string
+	Name         string
+	DefaultValue *Value
+	Type         *Type
+	Directives   DirectiveList
+	Position     *Position `dump:"-" json:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+}
+
+type EnumValueDefinition struct {
+	Description string
+	Name        string
+	Directives  DirectiveList
+	Position    *Position `dump:"-" json:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+}
+
+type DirectiveDefinition struct {
+	Description  string
+	Name         string
+	Arguments    ArgumentDefinitionList
+	Locations    []DirectiveLocation
+	IsRepeatable bool
+	Position     *Position `dump:"-" json:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/directive.go

@@ -0,0 +1,43 @@
+package ast
+
+type DirectiveLocation string
+
+const (
+	// Executable
+	LocationQuery              DirectiveLocation = `QUERY`
+	LocationMutation           DirectiveLocation = `MUTATION`
+	LocationSubscription       DirectiveLocation = `SUBSCRIPTION`
+	LocationField              DirectiveLocation = `FIELD`
+	LocationFragmentDefinition DirectiveLocation = `FRAGMENT_DEFINITION`
+	LocationFragmentSpread     DirectiveLocation = `FRAGMENT_SPREAD`
+	LocationInlineFragment     DirectiveLocation = `INLINE_FRAGMENT`
+
+	// Type System
+	LocationSchema               DirectiveLocation = `SCHEMA`
+	LocationScalar               DirectiveLocation = `SCALAR`
+	LocationObject               DirectiveLocation = `OBJECT`
+	LocationFieldDefinition      DirectiveLocation = `FIELD_DEFINITION`
+	LocationArgumentDefinition   DirectiveLocation = `ARGUMENT_DEFINITION`
+	LocationInterface            DirectiveLocation = `INTERFACE`
+	LocationUnion                DirectiveLocation = `UNION`
+	LocationEnum                 DirectiveLocation = `ENUM`
+	LocationEnumValue            DirectiveLocation = `ENUM_VALUE`
+	LocationInputObject          DirectiveLocation = `INPUT_OBJECT`
+	LocationInputFieldDefinition DirectiveLocation = `INPUT_FIELD_DEFINITION`
+	LocationVariableDefinition   DirectiveLocation = `VARIABLE_DEFINITION`
+)
+
+type Directive struct {
+	Name      string
+	Arguments ArgumentList
+	Position  *Position `dump:"-" json:"-"`
+
+	// Requires validation
+	ParentDefinition *Definition
+	Definition       *DirectiveDefinition
+	Location         DirectiveLocation
+}
+
+func (d *Directive) ArgumentMap(vars map[string]interface{}) map[string]interface{} {
+	return arg2map(d.Definition.Arguments, d.Arguments, vars)
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/document.go

@@ -0,0 +1,89 @@
+package ast
+
+type QueryDocument struct {
+	Operations OperationList
+	Fragments  FragmentDefinitionList
+	Position   *Position `dump:"-" json:"-"`
+	Comment    *CommentGroup
+}
+
+type SchemaDocument struct {
+	Schema          SchemaDefinitionList
+	SchemaExtension SchemaDefinitionList
+	Directives      DirectiveDefinitionList
+	Definitions     DefinitionList
+	Extensions      DefinitionList
+	Position        *Position `dump:"-" json:"-"`
+	Comment         *CommentGroup
+}
+
+func (d *SchemaDocument) Merge(other *SchemaDocument) {
+	d.Schema = append(d.Schema, other.Schema...)
+	d.SchemaExtension = append(d.SchemaExtension, other.SchemaExtension...)
+	d.Directives = append(d.Directives, other.Directives...)
+	d.Definitions = append(d.Definitions, other.Definitions...)
+	d.Extensions = append(d.Extensions, other.Extensions...)
+}
+
+type Schema struct {
+	Query            *Definition
+	Mutation         *Definition
+	Subscription     *Definition
+	SchemaDirectives DirectiveList
+
+	Types      map[string]*Definition
+	Directives map[string]*DirectiveDefinition
+
+	PossibleTypes map[string][]*Definition
+	Implements    map[string][]*Definition
+
+	Description string
+
+	Comment *CommentGroup
+}
+
+// AddTypes is the helper to add types definition to the schema
+func (s *Schema) AddTypes(defs ...*Definition) {
+	if s.Types == nil {
+		s.Types = make(map[string]*Definition)
+	}
+	for _, def := range defs {
+		s.Types[def.Name] = def
+	}
+}
+
+func (s *Schema) AddPossibleType(name string, def *Definition) {
+	s.PossibleTypes[name] = append(s.PossibleTypes[name], def)
+}
+
+// GetPossibleTypes will enumerate all the definitions for a given interface or union
+func (s *Schema) GetPossibleTypes(def *Definition) []*Definition {
+	return s.PossibleTypes[def.Name]
+}
+
+func (s *Schema) AddImplements(name string, iface *Definition) {
+	s.Implements[name] = append(s.Implements[name], iface)
+}
+
+// GetImplements returns all the interface and union definitions that the given definition satisfies
+func (s *Schema) GetImplements(def *Definition) []*Definition {
+	return s.Implements[def.Name]
+}
+
+type SchemaDefinition struct {
+	Description    string
+	Directives     DirectiveList
+	OperationTypes OperationTypeDefinitionList
+	Position       *Position `dump:"-" json:"-"`
+
+	BeforeDescriptionComment *CommentGroup
+	AfterDescriptionComment  *CommentGroup
+	EndOfDefinitionComment   *CommentGroup
+}
+
+type OperationTypeDefinition struct {
+	Operation Operation
+	Type      string
+	Position  *Position `dump:"-" json:"-"`
+	Comment   *CommentGroup
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/dumper.go

@@ -0,0 +1,159 @@
+package ast
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Dump turns ast into a stable string format for assertions in tests
+func Dump(i interface{}) string {
+	v := reflect.ValueOf(i)
+
+	d := dumper{Buffer: &bytes.Buffer{}}
+	d.dump(v)
+
+	return d.String()
+}
+
+type dumper struct {
+	*bytes.Buffer
+	indent int
+}
+
+type Dumpable interface {
+	Dump() string
+}
+
+func (d *dumper) dump(v reflect.Value) {
+	if dumpable, isDumpable := v.Interface().(Dumpable); isDumpable {
+		d.WriteString(dumpable.Dump())
+		return
+	}
+	switch v.Kind() {
+	case reflect.Bool:
+		if v.Bool() {
+			d.WriteString("true")
+		} else {
+			d.WriteString("false")
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fmt.Fprintf(d, "%d", v.Int())
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		fmt.Fprintf(d, "%d", v.Uint())
+
+	case reflect.Float32, reflect.Float64:
+		fmt.Fprintf(d, "%.2f", v.Float())
+
+	case reflect.String:
+		if v.Type().Name() != "string" {
+			d.WriteString(v.Type().Name() + "(" + strconv.Quote(v.String()) + ")")
+		} else {
+			d.WriteString(strconv.Quote(v.String()))
+		}
+
+	case reflect.Array, reflect.Slice:
+		d.dumpArray(v)
+
+	case reflect.Interface, reflect.Ptr:
+		d.dumpPtr(v)
+
+	case reflect.Struct:
+		d.dumpStruct(v)
+
+	default:
+		panic(fmt.Errorf("unsupported kind: %s\n buf: %s", v.Kind().String(), d.String()))
+	}
+}
+
+func (d *dumper) writeIndent() {
+	d.WriteString(strings.Repeat("  ", d.indent))
+}
+
+func (d *dumper) nl() {
+	d.WriteByte('\n')
+	d.writeIndent()
+}
+
+func typeName(t reflect.Type) string {
+	if t.Kind() == reflect.Ptr {
+		return typeName(t.Elem())
+	}
+	return t.Name()
+}
+
+func (d *dumper) dumpArray(v reflect.Value) {
+	d.WriteString("[" + typeName(v.Type().Elem()) + "]")
+
+	for i := 0; i < v.Len(); i++ {
+		d.nl()
+		d.WriteString("- ")
+		d.indent++
+		d.dump(v.Index(i))
+		d.indent--
+	}
+}
+
+func (d *dumper) dumpStruct(v reflect.Value) {
+	d.WriteString("<" + v.Type().Name() + ">")
+	d.indent++
+
+	typ := v.Type()
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		if typ.Field(i).Tag.Get("dump") == "-" {
+			continue
+		}
+
+		if isZero(f) {
+			continue
+		}
+		d.nl()
+		d.WriteString(typ.Field(i).Name)
+		d.WriteString(": ")
+		d.dump(v.Field(i))
+	}
+
+	d.indent--
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Interface:
+		return v.IsNil()
+	case reflect.Func, reflect.Map:
+		return v.IsNil()
+
+	case reflect.Array, reflect.Slice:
+		if v.IsNil() {
+			return true
+		}
+		z := true
+		for i := 0; i < v.Len(); i++ {
+			z = z && isZero(v.Index(i))
+		}
+		return z
+	case reflect.Struct:
+		z := true
+		for i := 0; i < v.NumField(); i++ {
+			z = z && isZero(v.Field(i))
+		}
+		return z
+	case reflect.String:
+		return v.String() == ""
+	}
+
+	// Compare other types directly:
+	return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()))
+}
+
+func (d *dumper) dumpPtr(v reflect.Value) {
+	if v.IsNil() {
+		d.WriteString("nil")
+		return
+	}
+	d.dump(v.Elem())
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/fragment.go

@@ -0,0 +1,41 @@
+package ast
+
+type FragmentSpread struct {
+	Name       string
+	Directives DirectiveList
+
+	// Require validation
+	ObjectDefinition *Definition
+	Definition       *FragmentDefinition
+
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+}
+
+type InlineFragment struct {
+	TypeCondition string
+	Directives    DirectiveList
+	SelectionSet  SelectionSet
+
+	// Require validation
+	ObjectDefinition *Definition
+
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+}
+
+type FragmentDefinition struct {
+	Name string
+	// Note: fragment variable definitions are experimental and may be changed
+	// or removed in the future.
+	VariableDefinition VariableDefinitionList
+	TypeCondition      string
+	Directives         DirectiveList
+	SelectionSet       SelectionSet
+
+	// Require validation
+	Definition *Definition
+
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/operation.go

@@ -0,0 +1,32 @@
+package ast
+
+type Operation string
+
+const (
+	Query        Operation = "query"
+	Mutation     Operation = "mutation"
+	Subscription Operation = "subscription"
+)
+
+type OperationDefinition struct {
+	Operation           Operation
+	Name                string
+	VariableDefinitions VariableDefinitionList
+	Directives          DirectiveList
+	SelectionSet        SelectionSet
+	Position            *Position `dump:"-" json:"-"`
+	Comment             *CommentGroup
+}
+
+type VariableDefinition struct {
+	Variable     string
+	Type         *Type
+	DefaultValue *Value
+	Directives   DirectiveList
+	Position     *Position `dump:"-" json:"-"`
+	Comment      *CommentGroup
+
+	// Requires validation
+	Definition *Definition
+	Used       bool `dump:"-"`
+}