repository-provider 35.0.3 → 35.1.0

package/src/pull-request.mjs

@@ -77,7 +77,7 @@ export class PullRequest extends OwnedObject {
    * @param {Branch?} [filter.source]
    * @param {Branch?} [filter.destination]
    * @param {Set<string>} [filter.states]
-   * @return {AsyncIterator<PullRequest>}
+   * @return {AsyncIterable<PullRequest>}
    */
   static async *list(repository, filter) {}
 
@@ -228,7 +228,7 @@ export class PullRequest extends OwnedObject {
   async decline() {}
 
   /**
-   * @return {AsyncIterator<Review>}
+   * @return {AsyncIterable<Review>}
    */
   async *reviews() {}
 

package/src/ref.mjs

@@ -10,6 +10,7 @@ import { name_attribute, boolean_attribute } from "./attributes.mjs";
 /**
  * Base for Branch and Tag
  */
+// @ts-ignore
 export class Ref extends OwnedObject {
   /**
    * options
@@ -55,13 +56,13 @@ export class Ref extends OwnedObject {
   /**
    * List entries of the branch.
    * @param {string[]|string} [matchingPatterns]
-   * @return {AsyncIterator<ContentEntry>} all matching entries in the branch
+   * @return {AsyncGenerator<ContentEntry>} all matching entries in the branch
    */
   async *entries(matchingPatterns) {}
 
   /**
    * List all entries of the branch.
-   * @return {AsyncIterator<ContentEntry>} all entries in the branch
+   * @return {AsyncGenerator<ContentEntry>} all entries in the branch
    */
   async *[Symbol.asyncIterator]() {
     return yield* this.entries();

package/src/repository-owner.mjs

@@ -1,7 +1,7 @@
 import { matcher } from "matching-iterator";
 import { Branch } from "./branch.mjs";
 import { Repository } from "./repository.mjs";
-import { NamedObject } from "./named-object.mjs";
+import { OwnedObject } from "./owned-object.mjs";
 import { asArray, stripBaseName, stripBaseNames } from "./util.mjs";
 
 /**
@@ -54,7 +54,7 @@ export function RepositoryOwner(base) {
     /**
      * List repositories for the owner.
      * @param {string[]|string} [patterns]
-     * @return {AsyncIterator<Repository>} all matching repositories of the owner
+     * @return {AsyncIterable<Repository>} all matching repositories of the owner
      */
     async *repositories(patterns) {
       patterns = asArray(patterns);
@@ -87,7 +87,7 @@ export function RepositoryOwner(base) {
      * @param {string} [name]
      * @param {function} [split]
      * @param {Object} [defaultItem]
-     * @returns {Promise<NamedObject|undefined>} from a repository
+     * @returns {Promise<OwnedObject|undefined>} from a repository
      */
     async lookup(type, name, split, defaultItem) {
       if (name !== undefined) {
@@ -114,7 +114,7 @@ export function RepositoryOwner(base) {
      * @param {string[]|string} [patterns]
      * @param {function} [split]
      * @param {Object} [defaultItem]
-     * @return {AsyncIterator<NamedObject>} matching type and pattern
+     * @return {AsyncIterable<OwnedObject>} matching type and pattern
      */
     async *list(type, patterns, split, defaultItem) {
       await this.initializeRepositories();
@@ -206,7 +206,7 @@ export function RepositoryOwner(base) {
     /**
      * List branches for the owner.
      * @param {string[]|string} [patterns]
-     * @return {AsyncIterator<Branch>} all matching branches of the owner
+     * @return {AsyncIterable<Branch>} all matching branches of the owner
      */
     async *branches(patterns) {
       yield* this.list(

package/src/repository.mjs

@@ -78,12 +78,12 @@ export class Repository extends OwnedObject {
     };
   }
 
-  #branches = new Map();
-  #tags = new Map();
+  /** @type {Map<string,Branch>} */ #branches = new Map();
+  /** @type {Map<string,Tag>} */ #tags = new Map();
   #projects = new Map();
   #applications = new Map();
   #milestones = new Map();
-  #pullRequests = new Map();
+  /** @type {Map<string,PullRequest>} */ #pullRequests = new Map();
   #hooks = [];
 
   constructor(owner, name, options) {
@@ -118,7 +118,7 @@ export class Repository extends OwnedObject {
   /**
    * List entries of the default branch.
    * @param {string[]|string} [patterns]
-   * @return {AsyncIterator<ContentEntry>} all matching entries in the branch
+   * @return {AsyncIterable<ContentEntry>} all matching entries in the branch
    */
   async *entries(patterns) {
     yield* (await this.defaultBranch).entries(patterns);
@@ -136,7 +136,7 @@ export class Repository extends OwnedObject {
   /**
    * List commits of the default branch.
    * @param {Object} [options]
-   * @return {AsyncIterator<Commit>} all matching commits in the repository
+   * @return {AsyncIterable<Commit>} all matching commits in the repository
    */
   async *commits(options) {}
 
@@ -145,12 +145,12 @@ export class Repository extends OwnedObject {
    * @return {string}
    */
   get cloneURL() {
-    return this.url;
+    return `git+${this.url}.git`;
   }
 
   /**
    * The url of issue tracking system.
-   * @return {string}
+   * @return {string|undefined}
    */
   get issuesURL() {
     return undefined;
@@ -158,7 +158,7 @@ export class Repository extends OwnedObject {
 
   /**
    * The url of home page.
-   * @return {string}
+   * @return {string|undefined}
    */
   get homePageURL() {
     return undefined;
@@ -236,7 +236,7 @@ export class Repository extends OwnedObject {
 
   /**
    * @param {string[]|string} [patterns]
-   * @return {AsyncIterator<Branch>} of all branches
+   * @return {AsyncGenerator<Branch>} of all branches
    */
   async *branches(patterns) {
     await this.initializeBranches();
@@ -262,7 +262,7 @@ export class Repository extends OwnedObject {
    * Internal branch creation does not call repository.initialize()
    * @param {string} name of the new branch
    * @param {Object} [options] to be passed to the branch
-   * @return {Branch} newly created branch
+   * @return {Branch} newly created branch or already present one for the given name
    */
   addBranch(name, options) {
     const branch = this.#branches.get(name);
@@ -299,7 +299,7 @@ export class Repository extends OwnedObject {
 
   /**
    * @param {string[]|string} [patterns]
-   * @return {AsyncIterator<Tag>} of all tags
+   * @return {AsyncGenerator<Tag>} of all tags
    */
   async *tags(patterns) {
     await this.initializeTags();
@@ -358,7 +358,7 @@ export class Repository extends OwnedObject {
 
   /**
    * Deliver all {@link PullRequest}s.
-   * @return {AsyncIterator<PullRequest>} of all pull requests
+   * @return {AsyncGenerator<PullRequest>} of all pull requests
    */
   async *pullRequests() {
     await this.initializePullRequests();
@@ -414,7 +414,7 @@ export class Repository extends OwnedObject {
 
   /**
    * List hooks.
-   * @return {AsyncIterator<Hook>} all hooks of the repository
+   * @return {AsyncGenerator<Hook>} all hooks of the repository
    */
   async *hooks() {
     await this.initializeHooks();

package/src/single-group-provider.mjs

@@ -36,7 +36,7 @@ export class SingleGroupProvider extends RepositoryOwner(BaseProvider) {
   /**
    * List groups.
    * @param {string[]|string|undefined} patterns
-   * @return {AsyncIterator<RepositoryGroup>} always deliver the one and only present group
+   * @return {AsyncIterable<RepositoryGroup>} always deliver the one and only present group
    */
   async *repositoryGroups(patterns) {
     let found;

package/types/application.d.mts

@@ -0,0 +1,6 @@
+/**
+ *
+ */
+export class Application extends OwnedObject {
+}
+import { OwnedObject } from "./owned-object.mjs";

package/types/attribute-extras.d.mts

@@ -0,0 +1,59 @@
+/**
+ * Create properties from options and default options.
+ * Already present properties (direct) are skipped.
+ * The attribute list from the class will be applied to the
+ * options and merged with the given set of properties.
+ * ```js
+ * class aClass {
+ *   static get attributes() {
+ *     return { with_default: { default: 77 }};
+ *   }
+ * }
+ *
+ * definePropertiesFromOptions(new aClass());
+ * // equivalent to
+ * Object.definedProperties(new aClass(),{ with_default: { value: 77 }})
+ * ```
+ * @see Object.definedProperties()
+ * @see Object.getOwnPropertyDescriptor()
+ * @param {Object} object target object
+ * @param {Object} options as passed to object constructor
+ * @param {Object} properties object properties
+ * @param {Object} [attributes] attribute meta info
+ */
+export function definePropertiesFromOptions(object: any, options?: any, properties?: any, attributes?: any): void;
+/**
+ * Get default values.
+ * @param {Object} attributes
+ * @param {Object} object
+ * @return {Object} filled with default values
+ */
+export function defaultValues(attributes: any, object: any): any;
+/**
+ * Create json based on present options.
+ * In other words only produce key value pairs if value is defined.
+ * @param {Object} object
+ * @param {Object} initial
+ * @param {Object} attributes to operator on
+ * @return {Object} initial + defined values
+ */
+export function optionJSON(object: any, initial?: any, attributes?: any): any;
+/**
+ * Rename attributes.
+ * Filters out null, undefined and empty strings.
+ * ```js
+ * mapAttributes({a:1},{a:"a'"}) // {"a'": 1}
+ * ```
+ * @param {Object} object
+ * @param {Object} mapping
+ * @return {Object} keys renamed after mapping
+ */
+export function mapAttributes(object: any, mapping: any): any;
+/**
+ * Same as mapAttributes but with the inverse mapping.
+ * Filters out null, undefined and empty strings
+ * @param {Object} object
+ * @param {Object} [mapping]
+ * @return {Object} keys renamed after mapping
+ */
+export function mapAttributesInverse(object: any, mapping?: any): any;

package/types/attributes.d.mts

@@ -0,0 +1,99 @@
+export namespace default_attribute {
+    export let type: string;
+    export let writable: boolean;
+    export let mandatory: boolean;
+    let _private: boolean;
+    export { _private as private };
+    export let isKey: boolean;
+    export let additionalAttributes: any[];
+    export let env: any[];
+}
+export namespace boolean_attribute {
+    let writable_1: boolean;
+    export { writable_1 as writable };
+    let _default: boolean;
+    export { _default as default };
+    let type_1: string;
+    export { type_1 as type };
+}
+export namespace boolean_read_only_attribute {
+    let type_2: string;
+    export { type_2 as type };
+    let _default_1: boolean;
+    export { _default_1 as default };
+}
+export namespace uuid_attribute {
+    let isKey_1: boolean;
+    export { isKey_1 as isKey };
+}
+export namespace empty_attiribute {
+    let type_3: string;
+    export { type_3 as type };
+}
+export namespace secret_attribute {
+    let _private_1: boolean;
+    export { _private_1 as private };
+    let writable_2: boolean;
+    export { writable_2 as writable };
+}
+export namespace count_attribute {
+    let type_4: string;
+    export { type_4 as type };
+}
+export namespace size_attribute {
+    let type_5: string;
+    export { type_5 as type };
+}
+export namespace name_attribute {
+    let isKey_2: boolean;
+    export { isKey_2 as isKey };
+}
+export namespace url_attribute {
+    export let description: string;
+    let type_6: string;
+    export { type_6 as type };
+}
+export namespace description_attribute {
+    let description_1: string;
+    export { description_1 as description };
+    let writable_3: boolean;
+    export { writable_3 as writable };
+}
+export namespace id_attribute {
+    let isKey_3: boolean;
+    export { isKey_3 as isKey };
+    let description_2: string;
+    export { description_2 as description };
+}
+export namespace state_attribute {
+    let writable_4: boolean;
+    export { writable_4 as writable };
+}
+export namespace body_attribute {
+    let writable_5: boolean;
+    export { writable_5 as writable };
+}
+export namespace title_attribute {
+    let description_3: string;
+    export { description_3 as description };
+    let writable_6: boolean;
+    export { writable_6 as writable };
+}
+export namespace priority_attribute {
+    let type_7: string;
+    export { type_7 as type };
+    let _default_2: number;
+    export { _default_2 as default };
+    let writable_7: boolean;
+    export { writable_7 as writable };
+}
+export namespace active_attribute {
+    let type_8: string;
+    export { type_8 as type };
+    let _default_3: boolean;
+    export { _default_3 as default };
+    let writable_8: boolean;
+    export { writable_8 as writable };
+}
+export namespace language_attribute { }
+export namespace type_attribute { }

package/types/base-object.d.mts

@@ -0,0 +1,69 @@
+/**
+ * Creates an instance of BaseObject.
+ * @param {Object} options
+ * @param {Object} [additionalProperties]
+ *
+ * @property {string?} id
+ * @property {string?} description
+ */
+export class BaseObject {
+    /**
+     * @return {string} type we represent
+     */
+    static get type(): string;
+    /**
+     * ```
+     * Tag -> tags
+     * Repository -> repositories
+     * ```
+     * @return {string} name of the collection holding us in the owner
+     */
+    static get collectionName(): string;
+    /**
+     * Attributes definitions.
+     * @return {Object}
+     */
+    static get attributes(): any;
+    /**
+     * User modifyable attributes.
+     * @return {Object} writable attributes
+     */
+    static get writableAttributes(): any;
+    /**
+     * Map attributes between external and internal representation.
+     * @return {Object}
+     */
+    static get attributeMapping(): any;
+    constructor(options: any, additionalProperties: any);
+    /**
+     * Takes values from options.
+     * @param {Object} options
+     * @param {Object} [additionalProperties]
+     */
+    updateAttributes(options: any, additionalProperties?: any): void;
+    /**
+     * Save object attributes in the backing store.
+     */
+    update(): Promise<void>;
+    /**
+     * @return {string} fullName
+     */
+    toString(): string;
+    /**
+     * Complete name in the hierachy.
+     * @return {string}
+     */
+    get fullName(): string;
+    get identifier(): string;
+    /**
+     * By default cannot be written to.
+     * @return {boolean} false
+     */
+    get isWritable(): boolean;
+    /**
+     * Check for equality
+     * @param {BaseObject|undefined} other
+     * @return {boolean} true if other is present
+     */
+    equals(other: BaseObject | undefined): boolean;
+}