custom_elements_manifest_parser 0.1.0

data/lib/custom_elements_manifest_parser/data_types/css_part.rb

@@ -0,0 +1,32 @@
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # The name + description of a CSS Part
+    class CssPart < BaseStruct
+      # @!attribute name
+      #    @return [String] - Name of the CSS part
+      attribute :name, Types::Strict::String
+
+      # @!attribute summary
+      #    @return [nil, String] - A markdown summary suitable for display in a listing.
+      attribute :summary, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute description
+      #    @return [nil, String] - A markdown description.
+      attribute :description, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute deprecated
+      #     @return [nil, Boolean, String] -
+      #        Whether the CSS shadow part is deprecated.
+      #        If the value is a string, it's the reason for the deprecation.
+      attribute :deprecated, Types::Strict::String.optional | Types::Strict::Bool.optional.meta(required: false)
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/demo.rb

@@ -0,0 +1,29 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Links to a demo of the element
+    class Demo < BaseStruct
+      # @!attribute url
+      #    @return [String] -
+      #       Relative URL of the demo if it's published with the package. Absolute URL
+      #       if it's hosted.
+      attribute :url, Types::Strict::String
+
+      # @!attribute description
+      #    @return [String, nil] - A markdown description of the demo.
+      attribute :description, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute source
+      #    @return [SourceReference, nil]
+      attribute :source, Types::Nominal::Any.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:source] = parser.data_types[:source].new(source).visit(parser: parser) if source
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/event.rb

@@ -0,0 +1,40 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Documents events on a custom element
+    class Event < BaseStruct
+      # @!attribute name
+      #   @return [String] - Name of the event
+      attribute :name, Types::Strict::String
+
+      # @!attribute type
+      #    @return [Type] - The type of the event object that's fired.
+      attribute :type, Types::Nominal::Any.optional.meta(required: false)
+
+      # @param summary [nil, String] - A markdown summary suitable for display in a listing.
+      attribute :summary, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute description
+      #    @return [nil, String] - A markdown description.
+      attribute :description, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute inheritedFrom
+      #    @return [nil, Reference]
+      attribute :inheritedFrom, Types::Nominal::Any.optional.meta(required: false)
+
+      # @!attribute deprecated
+      #   @return [nil, Boolean, String]
+      #      Whether the event is deprecated.
+      #      If the value is a string, it's the reason for the deprecation.
+      attribute :deprecated, Types::Strict::String.optional | Types::Strict::Bool.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:type] = parser.data_types[:type].new(type).visit(parser: parser) if type
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/function_return_type.rb

@@ -0,0 +1,25 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Abstract class for documenting a FunctionReturnType
+    class FunctionReturnType < BaseStruct
+      # @!attribute type
+      #   @return [Type, nil] - The type of the function return
+      attribute :type, Types::Strict::String | Types::Strict::Hash.optional.meta(required: false)
+
+      # @!attribute summary
+      #   @return [String, nil] Summary of the function return
+      attribute :summary, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute description
+      #   @return [String, nil] Description of the function return
+      attribute :description, Types::Strict::String.optional.meta(required: false)
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/parameter.rb

@@ -0,0 +1,33 @@
+require_relative "../structs/property_like_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Documents a parameter on a function
+    class Parameter < BaseStruct
+      # @!parse include Structs::PropertyLikeStruct
+      attributes_from Structs::PropertyLikeStruct
+
+      # @!attribute optional
+      #    @return [Boolean, nil] - Whether the parameter is optional. Undefined implies non-optional.
+      attribute :optional, Types::Strict::Bool.optional.meta(required: false)
+
+      # @!attribute rest
+      #    @return [Boolean, nil] -
+      #       Whether the parameter is a rest parameter. Only the last parameter may be a rest parameter.
+      #       Undefined implies single parameter.
+      attribute :rest, Types::Strict::Bool.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+
+        hash = hash.merge(
+          Structs::PropertyLikeStruct.build_hash(parser: parser, struct: self)
+        )
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/reference.rb

@@ -0,0 +1,36 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # A reference to an export of a module.
+    #
+    # All references are required to be publically accessible, so the canonical
+    # representation of a reference is the export it's available from.
+    #
+    # `package` should generally refer to an npm package name. If `package` is
+    # undefined then the reference is local to this package. If `module` is
+    # undefined the reference is local to the containing module.
+    #
+    # References to global symbols like `Array`, `HTMLElement`, or `Event` should
+    # use a `package` name of `"global:"`.
+    #
+    class Reference < BaseStruct
+      # @!attribute name
+      #    @return [String] - Name of the reference
+      attribute :name, Types::Strict::String
+
+      # @!attribute package
+      #    @return [String, nil] - Name of the package
+      attribute :package, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute module
+      #    @return [String, nil]
+      attribute :module, Types::Strict::String.optional.meta(required: false)
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/resolve_initializer.rb

@@ -0,0 +1,16 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # This shouldn't be here, but was thrown up by CEM.
+    class ResolveInitializer < BaseStruct
+      # @return [String, nil]
+      attribute :module, Types::Strict::String.optional.meta(required: false)
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/slot.rb

@@ -0,0 +1,31 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Documents slots for a custom element
+    class Slot < BaseStruct
+      # @!attribute name
+      #    @return [String] - The slot name, or the empty string for an unnamed slot.
+      attribute :name, Types::Strict::String
+
+      # @!attribute summary
+      #    @return [String, nil] - A markdown summary suitable for display in a listing.
+      attribute :summary, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute description
+      #    @return [String, nil] - A markdown description.
+      attribute :description, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute deprecated
+      #    @return [nil, Boolean, String] -
+      #       Whether the slot is deprecated.
+      #       If the value is a string, it's the reason for the deprecation.
+      attribute :deprecated, Types::Strict::String.optional | Types::Strict::Bool.optional.meta(required: false)
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/source_reference.rb

@@ -0,0 +1,17 @@
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Gets passed an href to an absolute URL to the source.
+    class SourceReference < BaseStruct
+      # @!attribute href
+      #   @return [String] - An absolute URL to the source (ie. a GitHub URL).
+      attribute :href, Types::Strict::String
+
+      def visit(parser:)
+        self
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/type.rb

@@ -0,0 +1,34 @@
+require_relative "../types.rb"
+require_relative "../base_struct.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # Documents a JSDoc, Closure, or TypeScript type.
+    class Type < BaseStruct
+      # @param text [String] -
+      #   The full string representation of the type, in whatever type syntax is
+      #   used, such as JSDoc, Closure, or TypeScript.
+      attribute :text, Types::Strict::String
+
+      # @!attribute references
+      #     @return [nil, Array<TypeReference> -
+      #        An array of references to the types in the type string.
+      #        These references have optional indices into the type string so that tools
+      #        can understand the references in the type string independently of the type
+      #        system and syntax. For example, a documentation viewer could display the
+      #        type `Array<FooElement | BarElement>` with cross-references to `FooElement`
+      #        and `BarElement` without understanding arrays, generics, or union types.
+      attribute :references, Types::Strict::Array.optional.meta(required: false)
+
+      # @!attribute source
+      #     @return [nil, SourceReference]
+      attribute :source, Types::Nominal::Any.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:references] = references.map { |reference| parser.data_types[:type_reference].new(reference).visit(parser: parser) } unless references.nil?
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/data_types/type_reference.rb

@@ -0,0 +1,22 @@
+require_relative "./reference.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module DataTypes
+    # A reference that is associated with a type string and optionally a range
+    # within the string.
+    #
+    # Start and end must both be present or not present. If they're present, they
+    # are indices into the associated type string. If they are missing, the entire
+    # type string is the symbol referenced and the name should match the type
+    # string.
+    class TypeReference < Reference
+      # @param start [Integer, nil]
+      attribute :start, Types::Strict::Integer.optional.meta(required: false)
+
+      # @!attribute end
+      #    @return [Integer, nil]
+      attribute :end, Types::Strict::Integer.optional.meta(required: false)
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/class_declaration.rb

@@ -0,0 +1,39 @@
+require_relative "../structs/declarable_node_struct.rb"
+require_relative "../structs/custom_element_like_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # This is equivalent to CustomElementDeclaration.
+    class ClassDeclaration < BaseStruct
+      # @return ["class"]
+      def self.kind; 'class'; end
+
+
+      # @!parse include Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @!parse include Structs::CustomElementLikeStruct
+      attributes_from Structs::CustomElementLikeStruct
+
+      # @!attribute kind
+      #    @return ["class"]
+      attribute :kind, Types.Value("class")
+
+      # @param parser [Parser] - Gets passed a parser
+      # @return [ClassDeclaration]
+      def visit(parser:)
+        hash = {}
+
+        hash = hash.merge(
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: self),
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: self)
+        )
+
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/class_field.rb

@@ -0,0 +1,50 @@
+require_relative "../structs/property_like_struct.rb"
+require_relative "../structs/declarable_node_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # Documents a class property. This does not get used directly. Instead, it gets extended by CustomElementField.
+    class ClassField < BaseStruct
+      # @return ["field"]
+      def self.kind; "field"; end
+
+      # @!attribute kind
+      #    @return ['field']
+      attribute :kind, Types.Value("field")
+
+      # @!attribute privacy
+      #    @return ["protected", "public", "private", nil]
+      attribute :static, Types.privacy.optional.meta(required: false)
+
+      # @!attribute inheritedFrom
+      #    @return [Reference, nil]
+      attribute :inheritedFrom, Types::Nominal::Any.optional.meta(required: false)
+
+      # @!attribute source
+      #    @return [SourceReference, nil]
+      attribute :source, Types::Nominal::Any.optional.meta(required: false)
+
+      # @!parse include Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @!parse include Structs::PropertyLikeStruct
+      attributes_from Structs::PropertyLikeStruct
+
+      def visit(parser:)
+        hash = {}
+        hash[:inheritedFrom] = parser.data_types[:inherited_from].new(inheritedFrom).visit(parser: parser) unless inheritedFrom.nil?
+        hash[:source] = parser.data_types[:source].new(source).visit(parser: parser) unless source.nil?
+
+        hash = hash.merge(
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: struct),
+          Structs::PropertyLikeStruct.build_hash(parser: parser, struct: struct)
+        )
+
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/class_method.rb

@@ -0,0 +1,55 @@
+require_relative "../structs/declarable_node_struct.rb"
+require_relative "../structs/function_like_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # Documents a method attached to a class
+    class ClassMethod < BaseStruct
+
+      # @!parse Structs::FunctionLikeStruct
+      attributes_from Structs::FunctionLikeStruct
+
+      # @!parse Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @return ["method"]
+      def self.kind; 'method'; end
+
+      # @!attribute kind
+      #   @return ["method"]
+      attribute :kind, Types.Value("method")
+
+      # @!attribute static
+      #   @return [Boolean, nil]
+      attribute :static, Types::Strict::Bool.optional.meta(required: false)
+
+      # @!attribute privacy
+      #   @return [Types.privacy, nil]
+      attribute :privacy, Types.privacy.optional.meta(required: false)
+
+      # @!attribute inheritedFrom
+      #   @return [Reference, nil]
+      attribute :inheritedFrom, Types::Nominal::Any.optional.meta(required: false)
+
+      # @!attribute source
+      #   @return [SourceReference, nil]
+      attribute :source, Types::Nominal::Any.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:inheritedFrom] = parser.data_types[:inherited_from].new(inheritedFrom).visit(parser: parser) unless inheritedFrom.nil?
+        hash[:source] = parser.data_types[:source].new(source).visit(parser: parser) unless source.nil?
+
+        hash = hash.merge(
+          Structs::FunctionLikeStruct.build_hash(parser: parser, struct: struct),
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: struct)
+        )
+
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/custom_element_export.rb

@@ -0,0 +1,52 @@
+require_relative "../structs/declarable_node_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    #
+    # A global custom element defintion, ie the result of a
+    # `customElements.define()` call.
+    #
+    # This is represented as an export because a definition makes the element
+    # available outside of the module it's defined it.
+    #
+    class CustomElementExport < BaseStruct
+      # @return ["custom-element-definition"]
+      def self.kind; "custom-element-definition"; end
+
+      # @!attribute kind
+      #    @return ["custom-element-definition"]
+      attribute :kind, Types.Value("custom-element-definition")
+
+      # @!parse Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @!attribute name
+      #    @return [String] - The tag name of the custom element
+      attribute :name, Types::Strict::String
+
+      # @!attribute declaration
+      #   @return [Reference]
+      #     A reference to the class or other declaration that implements the
+      #     custom element.
+      attribute :declaration, Types::Nominal::Any
+
+      # @param deprecated [boolean, string, nil]
+      #  Whether the custom-element export is deprecated.
+      #  For example, a future version will not register the custom element in this file.
+      #  If the value is a string, it's the reason for the deprecation.
+      attribute :deprecated, Types::Strict::Bool.optional | Types::Strict::String.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:declaration] = parser.data_types[:declaration].new(declaration).visit(parser: parser)
+        hash = hash.merge(
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: self)
+        )
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/custom_element_field.rb

@@ -0,0 +1,23 @@
+require_relative "./class_field.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # Additional metadata for fields on custom elements.
+    # This is equivalent to "ClassField"
+    class CustomElementField < ClassField
+      # @!attribute attribute
+      #   @return [String, nil] -
+      #     The corresponding attribute name if there is one.
+      #     If this property is defined, the attribute must be listed in the classes'
+      #     `attributes` array.
+      attribute :attribute, Types::Strict::String.optional.meta(required: false)
+
+      # @!attribute reflects
+      #   @return [Boolean, nil] -
+      #     If the property reflects to an attribute.
+      #     If this is true, the `attribute` property must be defined.
+      attribute :reflects, Types::Strict::Bool.optional.meta(required: false)
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/function_declaration.rb

@@ -0,0 +1,39 @@
+require_relative "../structs/declarable_node_struct.rb"
+require_relative "../structs/function_like_struct.rb"
+
+require_relative "../base_struct.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # Documents a function
+    class FunctionDeclaration < BaseStruct
+      # @!parse include Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @!parse include Structs::FunctionLikeStruct
+      attributes_from Structs::FunctionLikeStruct
+
+      # @return ["function"]
+      def self.kind; "function"; end
+
+      # @!attribute kind
+      #   @return ["function"]
+      attribute :kind, Types.Value("function")
+
+      # @!attribute source
+      #   @return [SourceReference, nil]
+      attribute :source, Types::Strict::String.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:source] = parser.data_types[:source].new(source).visit(parser: parser) unless source.nil?
+
+        hash = hash.merge(
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: self),
+          Structs::FunctionLikeStruct.build_hash(parser: parser, struct: self)
+        )
+        new(hash)
+      end
+    end
+  end
+end

data/lib/custom_elements_manifest_parser/nodes/javascript_export.rb

@@ -0,0 +1,59 @@
+require_relative "../structs/declarable_node_struct.rb"
+
+require_relative "../base_struct.rb"
+require_relative "../types.rb"
+
+module CustomElementsManifestParser
+  module Nodes
+    # A JavaScript export!
+    class JavaScriptExport < BaseStruct
+      # @!parse include Structs::DeclarableNodeStruct
+      attributes_from Structs::DeclarableNodeStruct
+
+      # @!attribute kind
+      #   @return ["js"]
+      attribute :kind, Types.Value("js")
+
+      # @return ["js"]
+      def self.kind; "js"; end
+
+      # @!attribute name
+      #    @return [String] -
+      #       The name of the exported symbol.
+      #
+      #       JavaScript has a number of ways to export objects which determine the
+      #       correct name to use.
+      #
+      #       - Default exports must use the name "default".
+      #       - Named exports use the name that is exported. If the export is renamed
+      #         with the "as" clause, use the exported name.
+      #       - Aggregating exports (`* from`) should use the name `*`
+      attribute :name, Types::Strict::String
+
+      # @!attribute declaration
+      #   @return [Reference] -
+      #     A reference to the exported declaration.
+      #
+      #     In the case of aggregating exports, the reference's `module` field must be
+      #     defined and the `name` field must be `"*"`.
+      attribute :declaration, Types::Nominal::Any.optional.meta(required: false)
+
+      # @!attribute deprecated
+      #    @return [nil, boolean, string] -
+      #       Whether the export is deprecated. For example, the name of the export was changed.
+      #       If the value is a string, it's the reason for the deprecation.
+      attribute :deprecated, Types::Strict::String.optional | Types::Strict::Bool.optional.meta(required: false)
+
+      def visit(parser:)
+        hash = {}
+        hash[:declaration] = parser.data_types[:declaration].new(declaration).visit(parser: parser) if declaration
+
+        hash = hash.merge(
+          Structs::DeclarableNodeStruct.build_hash(parser: parser, struct: self)
+        )
+
+        new(hash)
+      end
+    end
+  end
+end