@sumaris-net/ngx-components 18.12.0 → 18.12.1

package/esm2022/src/app/core/services/base-graphql-service.class.mjs

@@ -0,0 +1,230 @@
+import { EntityUtils } from './model/entity.model';
+import { isNotEmptyArray, isNotNil, toBoolean } from '../../shared/functions';
+import { environment } from '../../../environments/environment';
+import { Directive, Optional } from '@angular/core';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { CryptoService } from './crypto.service';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../graphql/graphql.service";
+export class BaseGraphqlServiceOptions {
+    production;
+}
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class BaseGraphqlService extends StartableService {
+    graphql;
+    _logPrefix;
+    _mutableWatchQueries = [];
+    // Max updated queries, for this entity.
+    // - Can be override by subclasses (in constructor)
+    // - Use value -1 for no max size
+    // - Default value to 3, because it usually enough (e.g. OperationService and LandingService need at least 2)
+    _mutableWatchQueriesMaxCount = 3;
+    constructor(graphql, options) {
+        super(graphql);
+        this.graphql = graphql;
+        // for DEV only
+        this._debug = toBoolean(options && !options.production, !environment.production);
+        this._logPrefix = `[base-graphql-service] `;
+    }
+    mutableWatchQuery(opts) {
+        opts.fetchPolicy = opts.fetchPolicy || this.graphql.defaultFetchPolicy;
+        // Standard query (no cache)
+        if (opts.fetchPolicy === 'no-cache') {
+            return this.graphql.watchQuery(opts);
+        }
+        // No arrayFieldName
+        if (!opts.arrayFieldName) {
+            if (this._debug)
+                console.warn(this._logPrefix + "̀Missing 'opts.arrayFieldName' : unable to create a mutable watch query");
+            return this.graphql.watchQuery(opts);
+        }
+        // Create the query id
+        const queryId = this.computeMutableWatchQueryId(opts);
+        const exactMatchQueries = this._mutableWatchQueries.filter((q) => q.id === queryId);
+        let mutableQuery;
+        let queryRef;
+        if (exactMatchQueries.length === 1) {
+            mutableQuery = exactMatchQueries[0];
+            mutableQuery.counter += 1;
+            queryRef = mutableQuery.queryRef;
+            if (this._debug)
+                console.debug(this._logPrefix + `Find same mutable watch query (same variables) {${queryId}}. Skip register`);
+            // Refetch if need data from network
+            if (opts.fetchPolicy === 'network-only' || opts.fetchPolicy === 'cache-and-network') {
+                console.warn(this._logPrefix + ' Mutable query already exists, and fetchPolicy=' + opts.fetchPolicy + '. Force refetch query...');
+                queryRef.refetch(mutableQuery.variables);
+            }
+            //if (mutableQuery.counter > 3) {
+            //  console.warn(this._debugPrefix + 'TODO: clean previous queries with name: ' + queryName);
+            //}
+        }
+        else {
+            queryRef = this.graphql.watchQueryRef(opts);
+            this.registerNewMutableWatchQuery({
+                id: queryId,
+                query: opts.query,
+                queryRef,
+                variables: opts.variables,
+                arrayFieldName: opts.arrayFieldName,
+                totalFieldName: opts.totalFieldName,
+                insertFilterFn: opts.insertFilterFn,
+                sortFn: opts.sortFn,
+                counter: 1,
+            });
+        }
+        return this.graphql.queryRefValuesChanges(queryRef, opts).pipe(
+        // FIXME: find why sometimes data is an object, and not and array
+        filter((res) => Array.isArray(res[opts.arrayFieldName])));
+    }
+    insertIntoMutableCachedQueries(cache, opts) {
+        const queries = this.findMutableWatchQueries(opts);
+        if (!queries.length)
+            return;
+        queries.forEach((query) => {
+            if (Array.isArray(opts.data)) {
+                // Filter values, if a filter function exists
+                const data = query.insertFilterFn ? opts.data.filter((d) => query.insertFilterFn(d)) : opts.data;
+                if (isNotEmptyArray(data)) {
+                    if (this._debug)
+                        console.debug(`[base-data-service] Inserting data into watching query: `, query.id);
+                    this.graphql.addManyToQueryCache(cache, {
+                        query: query.query,
+                        variables: query.variables,
+                        arrayFieldName: query.arrayFieldName,
+                        totalFieldName: query.totalFieldName,
+                        sortFn: query.sortFn,
+                        data,
+                    });
+                }
+            }
+            // Filter value, if a filter function exists
+            else if (!query.insertFilterFn || query.insertFilterFn(opts.data)) {
+                if (this._debug)
+                    console.debug(`[base-data-service] Inserting data into watching query: `, query.id);
+                this.graphql.insertIntoQueryCache(cache, {
+                    query: query.query,
+                    variables: query.variables,
+                    arrayFieldName: query.arrayFieldName,
+                    totalFieldName: query.totalFieldName,
+                    sortFn: query.sortFn,
+                    data: opts.data,
+                });
+            }
+        });
+    }
+    removeFromMutableCachedQueriesByIds(cache, opts) {
+        const queries = this.findMutableWatchQueries(opts);
+        if (!queries.length)
+            return;
+        console.debug(`[base-data-service] Removing data from watching queries: `, queries);
+        return (queries
+            .map((query) => {
+            if (Array.isArray(opts.ids)) {
+                return this.graphql.removeFromCachedQueryByIds(cache, {
+                    query: query.query,
+                    variables: query.variables,
+                    arrayFieldName: query.arrayFieldName,
+                    totalFieldName: query.totalFieldName,
+                    ids: opts.ids,
+                });
+            }
+            else {
+                return this.graphql.removeFromCachedQueryById(cache, {
+                    query: query.query,
+                    variables: query.variables,
+                    arrayFieldName: query.arrayFieldName,
+                    totalFieldName: query.totalFieldName,
+                    ids: opts.ids,
+                })
+                    ? 1
+                    : 0;
+            }
+        })
+            // Sum
+            .reduce((res, count) => res + count, 0));
+    }
+    async refetchMutableWatchQueries(opts) {
+        // Retrieve queries to refetch
+        const queries = this.findMutableWatchQueries(opts);
+        // Skip if nothing to refetch
+        if (!queries.length)
+            return;
+        try {
+            await Promise.all(queries.map((query) => {
+                if (this._debug)
+                    console.debug(this._logPrefix + `Refetching mutable watch query {${query.id}}`);
+                return query.queryRef.refetch({ ...query.variables, ...opts.variables });
+            }));
+        }
+        catch (err) {
+            console.error(this._logPrefix + 'Error while refetching mutable watch queries', err);
+        }
+    }
+    /* -- protected methods -- */
+    computeMutableWatchQueryId(opts) {
+        const queryName = opts.queryName || CryptoService.sha256(JSON.stringify(opts.query)).substring(0, 8);
+        const variablesKey = (opts.variables && CryptoService.sha256(JSON.stringify(opts.variables)).substring(0, 8)) || '';
+        return [queryName, opts.arrayFieldName, variablesKey].join('|');
+    }
+    findMutableWatchQueries(opts) {
+        // Search by queryName
+        if (opts.queryName) {
+            return this._mutableWatchQueries.filter((q) => q.id.startsWith(opts.queryName + '|'));
+        }
+        if (opts.queryNames) {
+            return (opts.queryNames
+                .map((queryName) => this._mutableWatchQueries.filter((q) => q.id.startsWith(queryName + '|')))
+                // flatMap
+                .reduce((res, array) => res.concat(...array), []));
+        }
+        // Search by query
+        if (opts.query) {
+            return this._mutableWatchQueries.filter((q) => q.query === opts.query);
+        }
+        if (opts.queries) {
+            return (opts.queries
+                .filter(isNotNil)
+                .map((query) => this._mutableWatchQueries.filter((q) => q.query === query))
+                // flatMap
+                .reduce((res, array) => res.concat(...array), []));
+        }
+        throw Error('Invalid options: only one property must be set');
+    }
+    registerNewMutableWatchQuery(mutableQuery) {
+        if (this._debug)
+            console.debug(this._logPrefix + `Register new mutable watch query {${mutableQuery.id}}`);
+        // If exceed the max size of mutable queries: remove some
+        if (this._mutableWatchQueriesMaxCount > 0 && this._mutableWatchQueries.length >= this._mutableWatchQueriesMaxCount) {
+            const removedWatchQueries = this._mutableWatchQueries.splice(0, 1 + this._mutableWatchQueries.length - this._mutableWatchQueriesMaxCount);
+            // Warn, as it shouldn't be happen often, when max is correctly set
+            console.warn(this._logPrefix + `Removing older mutable watching queries (stack exceed max of ${this._mutableWatchQueriesMaxCount}): `, removedWatchQueries.map((q) => q.id));
+        }
+        // Define the sort function (to be used in insertIntoMutableCachedQuery())
+        if (!mutableQuery.sortFn && mutableQuery.variables && mutableQuery.variables.sortBy) {
+            mutableQuery.sortFn =
+                mutableQuery.variables &&
+                    mutableQuery.variables.sortBy &&
+                    EntityUtils.sortComparator(mutableQuery.variables.sortBy, mutableQuery.variables.sortDirection || 'asc');
+        }
+        // Add the new mutable query to array
+        this._mutableWatchQueries.push(mutableQuery);
+    }
+    findRefetchQueries(opts) {
+        return (this.findMutableWatchQueries(opts)
+            // Workaround, to make refetch queries works: transform into a simple {query, variables}
+            .map(({ query, variables }) => ({ query, variables })));
+    }
+    ngOnStart() {
+        return Promise.resolve(null);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseGraphqlService, deps: [{ token: i1.GraphqlService }, { token: BaseGraphqlServiceOptions, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: BaseGraphqlService, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseGraphqlService, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.GraphqlService }, { type: BaseGraphqlServiceOptions, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-graphql-service.class.js","sourceRoot":"","sources":["../../../../../../src/app/core/services/base-graphql-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { GraphqlService, MutateQueryOptions, WatchQueryOptions } from '../graphql/graphql.service';\nimport { Page } from '../../shared/services/entity-service.class';\nimport { Observable } from 'rxjs';\nimport { FetchResult } from '@apollo/client/link/core';\nimport { EntityUtils } from './model/entity.model';\nimport { ApolloCache, InternalRefetchQueriesInclude } from '@apollo/client/core';\nimport { isNotEmptyArray, isNotNil, toBoolean } from '../../shared/functions';\nimport { environment } from '../../../environments/environment';\nimport { Directive, Optional } from '@angular/core';\nimport { QueryRef } from 'apollo-angular';\nimport { PureQueryOptions } from '@apollo/client/core/types';\nimport { DocumentNode } from 'graphql';\nimport { StartableService } from '../../shared/services/startable-service.class';\nimport { TypedDocumentNode } from '@graphql-typed-document-node/core';\nimport { CryptoService } from './crypto.service';\nimport { EmptyObject } from '../graphql/graphql.utils';\nimport { filter } from 'rxjs/operators';\n\nexport interface QueryVariables<F = any> extends Partial<Page> {\n  filter?: F;\n  [key: string]: any;\n}\n\nexport interface MutateQueryWithCacheUpdateOptions<T = any, V = EmptyObject> extends MutateQueryOptions<T, V> {\n  cacheInsert?: {\n    query: any;\n    fetchData: (variables: V, mutationResult: FetchResult<T>) => any;\n  }[];\n\n  cacheRemove?: {\n    query: any;\n    fetchIds: (variables: V) => number | number[];\n  }[];\n}\n\nexport interface MutableWatchQueryOptions<D, T = any, V = EmptyObject> extends WatchQueryOptions<V> {\n  queryName: string;\n  arrayFieldName: keyof D;\n  totalFieldName?: keyof D;\n  insertFilterFn?: (data: T) => boolean;\n  sortFn?: (a: T, b: T) => number;\n}\n\nexport interface MutableWatchQueryDescription<TData, TEntityClass = any, TVariables = EmptyObject> extends PureQueryOptions<TVariables, TData> {\n  id?: string;\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>;\n  queryRef: QueryRef<TData, TVariables>;\n  variables: TVariables;\n  arrayFieldName: keyof TData;\n  totalFieldName?: keyof TData;\n  insertFilterFn?: (data: TEntityClass) => boolean;\n  sortFn?: (a: TEntityClass, b: TEntityClass) => number;\n  counter: number;\n}\n\nexport interface FindMutableWatchQueriesOptions {\n  query?: DocumentNode;\n  queries?: DocumentNode[];\n  queryName?: string;\n  queryNames?: string[];\n}\n\nexport class BaseGraphqlServiceOptions {\n  production?: boolean;\n}\n\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport abstract class BaseGraphqlService<T = any, F = any, ID = any, S = void> extends StartableService<S> {\n  protected _logPrefix: string;\n  protected _mutableWatchQueries: MutableWatchQueryDescription<any>[] = [];\n\n  // Max updated queries, for this entity.\n  // - Can be override by subclasses (in constructor)\n  // - Use value -1 for no max size\n  // - Default value to 3, because it usually enough (e.g. OperationService and LandingService need at least 2)\n  protected _mutableWatchQueriesMaxCount = 3;\n\n  protected constructor(\n    protected graphql: GraphqlService,\n    @Optional() options?: BaseGraphqlServiceOptions\n  ) {\n    super(graphql);\n\n    // for DEV only\n    this._debug = toBoolean(options && !options.production, !environment.production);\n    this._logPrefix = `[base-graphql-service] `;\n  }\n\n  mutableWatchQuery<D, V = EmptyObject>(opts: MutableWatchQueryOptions<D, T, V>): Observable<D> {\n    opts.fetchPolicy = opts.fetchPolicy || this.graphql.defaultFetchPolicy;\n\n    // Standard query (no cache)\n    if (opts.fetchPolicy === 'no-cache') {\n      return this.graphql.watchQuery(opts);\n    }\n\n    // No arrayFieldName\n    if (!opts.arrayFieldName) {\n      if (this._debug) console.warn(this._logPrefix + \"̀Missing 'opts.arrayFieldName' : unable to create a mutable watch query\");\n      return this.graphql.watchQuery(opts);\n    }\n\n    // Create the query id\n    const queryId = this.computeMutableWatchQueryId(opts);\n    const exactMatchQueries = this._mutableWatchQueries.filter((q) => q.id === queryId);\n\n    let mutableQuery: MutableWatchQueryDescription<D, T, V>;\n    let queryRef: QueryRef<D, V>;\n\n    if (exactMatchQueries.length === 1) {\n      mutableQuery = exactMatchQueries[0] as MutableWatchQueryDescription<D, T, V>;\n      mutableQuery.counter += 1;\n      queryRef = mutableQuery.queryRef;\n      if (this._debug) console.debug(this._logPrefix + `Find same mutable watch query (same variables) {${queryId}}. Skip register`);\n\n      // Refetch if need data from network\n      if (opts.fetchPolicy === 'network-only' || opts.fetchPolicy === 'cache-and-network') {\n        console.warn(this._logPrefix + ' Mutable query already exists, and fetchPolicy=' + opts.fetchPolicy + '. Force refetch query...');\n        queryRef.refetch(mutableQuery.variables);\n      }\n      //if (mutableQuery.counter > 3) {\n      //  console.warn(this._debugPrefix + 'TODO: clean previous queries with name: ' + queryName);\n      //}\n    } else {\n      queryRef = this.graphql.watchQueryRef<D, V>(opts);\n      this.registerNewMutableWatchQuery({\n        id: queryId,\n        query: opts.query,\n        queryRef,\n        variables: opts.variables,\n        arrayFieldName: opts.arrayFieldName,\n        totalFieldName: opts.totalFieldName,\n        insertFilterFn: opts.insertFilterFn,\n        sortFn: opts.sortFn,\n        counter: 1,\n      });\n    }\n\n    return this.graphql.queryRefValuesChanges(queryRef, opts).pipe(\n      // FIXME: find why sometimes data is an object, and not and array\n      filter((res) => Array.isArray(res[opts.arrayFieldName]))\n    );\n  }\n\n  insertIntoMutableCachedQueries(\n    cache: ApolloCache<any>,\n    opts: FindMutableWatchQueriesOptions & {\n      data: T[] | T;\n    }\n  ) {\n    const queries = this.findMutableWatchQueries(opts);\n    if (!queries.length) return;\n\n    queries.forEach((query) => {\n      if (Array.isArray(opts.data)) {\n        // Filter values, if a filter function exists\n        const data = query.insertFilterFn ? opts.data.filter((d) => query.insertFilterFn(d)) : opts.data;\n        if (isNotEmptyArray(data)) {\n          if (this._debug) console.debug(`[base-data-service] Inserting data into watching query: `, query.id);\n          this.graphql.addManyToQueryCache(cache, {\n            query: query.query,\n            variables: query.variables,\n            arrayFieldName: query.arrayFieldName as string,\n            totalFieldName: query.totalFieldName as string,\n            sortFn: query.sortFn,\n            data,\n          });\n        }\n      }\n      // Filter value, if a filter function exists\n      else if (!query.insertFilterFn || query.insertFilterFn(opts.data)) {\n        if (this._debug) console.debug(`[base-data-service] Inserting data into watching query: `, query.id);\n        this.graphql.insertIntoQueryCache(cache, {\n          query: query.query,\n          variables: query.variables,\n          arrayFieldName: query.arrayFieldName as string,\n          totalFieldName: query.totalFieldName as string,\n          sortFn: query.sortFn,\n          data: opts.data,\n        });\n      }\n    });\n  }\n\n  removeFromMutableCachedQueriesByIds(\n    cache: ApolloCache<any>,\n    opts: FindMutableWatchQueriesOptions & {\n      ids: ID | ID[];\n    }\n  ): number {\n    const queries = this.findMutableWatchQueries(opts);\n    if (!queries.length) return;\n\n    console.debug(`[base-data-service] Removing data from watching queries: `, queries);\n    return (\n      queries\n        .map((query) => {\n          if (Array.isArray(opts.ids)) {\n            return this.graphql.removeFromCachedQueryByIds(cache, {\n              query: query.query,\n              variables: query.variables,\n              arrayFieldName: query.arrayFieldName as string,\n              totalFieldName: query.totalFieldName as string,\n              ids: opts.ids,\n            });\n          } else {\n            return this.graphql.removeFromCachedQueryById(cache, {\n              query: query.query,\n              variables: query.variables,\n              arrayFieldName: query.arrayFieldName as string,\n              totalFieldName: query.totalFieldName as string,\n              ids: opts.ids,\n            })\n              ? 1\n              : 0;\n          }\n        })\n        // Sum\n        .reduce((res, count) => res + count, 0)\n    );\n  }\n\n  async refetchMutableWatchQueries(opts: FindMutableWatchQueriesOptions & { variables?: any }): Promise<void> {\n    // Retrieve queries to refetch\n    const queries = this.findMutableWatchQueries(opts);\n\n    // Skip if nothing to refetch\n    if (!queries.length) return;\n\n    try {\n      await Promise.all(\n        queries.map((query) => {\n          if (this._debug) console.debug(this._logPrefix + `Refetching mutable watch query {${query.id}}`);\n          return query.queryRef.refetch({ ...query.variables, ...opts.variables });\n        })\n      );\n    } catch (err) {\n      console.error(this._logPrefix + 'Error while refetching mutable watch queries', err);\n    }\n  }\n\n  /* -- protected methods -- */\n\n  protected computeMutableWatchQueryId<D, T, V = EmptyObject>(opts: MutableWatchQueryOptions<D, T, V>) {\n    const queryName = opts.queryName || CryptoService.sha256(JSON.stringify(opts.query)).substring(0, 8);\n    const variablesKey = (opts.variables && CryptoService.sha256(JSON.stringify(opts.variables)).substring(0, 8)) || '';\n    return [queryName, opts.arrayFieldName, variablesKey].join('|');\n  }\n\n  protected findMutableWatchQueries(opts: FindMutableWatchQueriesOptions): MutableWatchQueryDescription<any>[] {\n    // Search by queryName\n    if (opts.queryName) {\n      return this._mutableWatchQueries.filter((q) => q.id.startsWith(opts.queryName + '|'));\n    }\n    if (opts.queryNames) {\n      return (\n        opts.queryNames\n          .map((queryName) => this._mutableWatchQueries.filter((q) => q.id.startsWith(queryName + '|')))\n          // flatMap\n          .reduce((res, array) => res.concat(...array), [])\n      );\n    }\n\n    // Search by query\n    if (opts.query) {\n      return this._mutableWatchQueries.filter((q) => q.query === opts.query);\n    }\n    if (opts.queries) {\n      return (\n        opts.queries\n          .filter(isNotNil)\n          .map((query) => this._mutableWatchQueries.filter((q) => q.query === query))\n          // flatMap\n          .reduce((res, array) => res.concat(...array), [])\n      );\n    }\n    throw Error('Invalid options: only one property must be set');\n  }\n\n  protected registerNewMutableWatchQuery(mutableQuery: MutableWatchQueryDescription<any>) {\n    if (this._debug) console.debug(this._logPrefix + `Register new mutable watch query {${mutableQuery.id}}`);\n\n    // If exceed the max size of mutable queries: remove some\n    if (this._mutableWatchQueriesMaxCount > 0 && this._mutableWatchQueries.length >= this._mutableWatchQueriesMaxCount) {\n      const removedWatchQueries = this._mutableWatchQueries.splice(0, 1 + this._mutableWatchQueries.length - this._mutableWatchQueriesMaxCount);\n\n      // Warn, as it shouldn't be happen often, when max is correctly set\n      console.warn(\n        this._logPrefix + `Removing older mutable watching queries (stack exceed max of ${this._mutableWatchQueriesMaxCount}): `,\n        removedWatchQueries.map((q) => q.id)\n      );\n    }\n\n    // Define the sort function (to be used in insertIntoMutableCachedQuery())\n    if (!mutableQuery.sortFn && mutableQuery.variables && mutableQuery.variables.sortBy) {\n      mutableQuery.sortFn =\n        mutableQuery.variables &&\n        mutableQuery.variables.sortBy &&\n        EntityUtils.sortComparator(mutableQuery.variables.sortBy, mutableQuery.variables.sortDirection || 'asc');\n    }\n\n    // Add the new mutable query to array\n    this._mutableWatchQueries.push(mutableQuery);\n  }\n\n  protected findRefetchQueries(opts: FindMutableWatchQueriesOptions): InternalRefetchQueriesInclude {\n    return (\n      this.findMutableWatchQueries(opts)\n        // Workaround, to make refetch queries works: transform into a simple {query, variables}\n        .map(({ query, variables }) => ({ query, variables }))\n    );\n  }\n\n  protected ngOnStart(): Promise<S> {\n    return Promise.resolve(null as S);\n  }\n}\n"]}

package/esm2022/src/app/core/services/base58.mjs

@@ -0,0 +1,83 @@
+// Base58 encoding/decoding
+// Originally written by Mike Hearn for BitcoinJ
+// Copyright (c) 2011 Google Inc
+// Ported to JavaScript by Stefan Thomas
+// Merged Buffer refactorings from base58-native by Stephen Pair
+// Copyright (c) 2013 BitPay Inc
+// Rewritten in TypeScript by Ludovic Pecquot
+// @dynamic
+export class Base58 {
+    static alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    static alphabetMap;
+    static getAlphabetMap() {
+        if (!Base58.alphabetMap) {
+            this.alphabetMap = {};
+            for (let i = 0; i < Base58.alphabet.length; i++) {
+                Base58.alphabetMap[Base58.alphabet.charAt(i)] = i;
+            }
+        }
+        return Base58.alphabetMap;
+    }
+    static encode(buffer) {
+        if (buffer.length === 0)
+            return '';
+        let i;
+        let j;
+        const digits = [0];
+        for (i = 0; i < buffer.length; i++) {
+            for (j = 0; j < digits.length; j++)
+                digits[j] <<= 8;
+            digits[digits.length - 1] += buffer[i];
+            let carry = 0;
+            for (j = digits.length - 1; j >= 0; j--) {
+                digits[j] += carry;
+                carry = (digits[j] / 58) | 0;
+                digits[j] %= 58;
+            }
+            while (carry) {
+                digits.unshift(carry);
+                carry = (digits[0] / 58) | 0;
+                digits[0] %= 58;
+            }
+        }
+        // deal with leading zeros
+        for (i = 0; i < buffer.length - 1 && buffer[i] === 0; i++)
+            digits.unshift(0);
+        return digits
+            .map(function (digit) {
+            return Base58.alphabet[digit];
+        })
+            .join('');
+    }
+    static decode(string) {
+        if (string.length === 0)
+            return new Uint8Array(0);
+        const input = string.split('').map(function (c) {
+            return Base58.getAlphabetMap()[c];
+        });
+        let i;
+        let j;
+        const bytes = [0];
+        for (i = 0; i < input.length; i++) {
+            for (j = 0; j < bytes.length; j++)
+                bytes[j] *= 58;
+            bytes[bytes.length - 1] += input[i];
+            let carry = 0;
+            for (j = bytes.length - 1; j >= 0; j--) {
+                bytes[j] += carry;
+                carry = bytes[j] >> 8;
+                bytes[j] &= 0xff;
+            }
+            while (carry) {
+                bytes.unshift(carry);
+                carry = bytes[0] >> 8;
+                bytes[0] &= 0xff;
+            }
+        }
+        // deal with leading zeros
+        for (i = 0; i < input.length - 1 && input[i] === 0; i++)
+            bytes.unshift(0);
+        return new Uint8Array(bytes);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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