hivesigner 3.3.5 → 4.1.0

package/src/client.ts

@@ -1,317 +0,0 @@
-import crossFetch from 'cross-fetch'
-import { CallbackFunction, ClientConfig, LoginOptions, SendResponse } from './types'
-import { API_URL, BASE_URL } from './consts'
-import { isBrowser } from './utilities'
-import { Operation } from '@hiveio/dhive'
-
-// Bind fetch to avoid "Illegal invocation" errors in browsers
-const fetch = crossFetch.bind(typeof globalThis !== 'undefined' ? globalThis : undefined)
-
-export class Client {
-	public apiURL: string
-	public app: string
-	public callbackURL: string
-	public scope: string[]
-	public responseType: string
-	public accessToken?: string
-
-	constructor(config: ClientConfig) {
-		this.apiURL = config.apiURL || API_URL
-		this.app = config.app
-		this.callbackURL = config.callbackURL
-		this.accessToken = config.accessToken
-		this.scope = config.scope
-		this.responseType = config.responseType
-	}
-
-	public setBaseURL(): this {
-		console.warn(
-			'The function "setBaseUrl" is deprecated, the base URL is always "https://hivesigner.com", you can only change the API URL with "setApiURL"'
-		)
-		return this
-	}
-
-	public setApiURL(url: string): this {
-		this.apiURL = url
-		return this
-	}
-
-	public setApp(app: string): this {
-		this.app = app
-		return this
-	}
-
-	public setCallbackURL(url: string): this {
-		this.callbackURL = url
-		return this
-	}
-
-	public setAccessToken(accessToken: string): this {
-		this.accessToken = accessToken
-		return this
-	}
-
-	public removeAccessToken(): this {
-		delete this.accessToken
-		return this
-	}
-
-	public setScope(scope: string[]): this {
-		this.scope = scope
-		return this
-	}
-
-	public getLoginURL(state: string, account?: string): string {
-		const redirectUri = encodeURIComponent(this.callbackURL)
-		let loginURL = `${BASE_URL}/oauth2/authorize?client_id=${this.app}&redirect_uri=${redirectUri}`
-		if (this.responseType === 'code') {
-			loginURL += `&response_type=${this.responseType}`
-		}
-		if (this.scope) {
-			loginURL += `&scope=${this.scope.join(',')}`
-		}
-		if (state) {
-			loginURL += `&state=${encodeURIComponent(state)}`
-		}
-		if (account) {
-			loginURL += `&account=${encodeURIComponent(account)}`
-		}
-		return loginURL
-	}
-
-	public login(options: LoginOptions): void {
-		if (isBrowser()) {
-			// @ts-ignore
-			window.location = this.getLoginURL(options.state)
-		}
-	}
-
-	public me(): Promise<SendResponse>
-	public me(cb: CallbackFunction): Promise<SendResponse>
-	public me(cb?: CallbackFunction): Promise<SendResponse> {
-		return this.send('me', 'POST', {}, cb)
-	}
-
-	public decode(memo: string): Promise<SendResponse>
-	public decode(memo: string, cb: CallbackFunction): Promise<SendResponse>
-	public decode(memo: string, cb?: CallbackFunction): Promise<SendResponse> {
-		return this.send('decode', 'POST', {memo: memo}, cb)
-	}
-
-	public vote(voter: string, author: string, permlink: string, weight: string | number): Promise<SendResponse>
-	public vote(
-		voter: string,
-		author: string,
-		permlink: string,
-		weight: string | number,
-		cb: CallbackFunction
-	): Promise<SendResponse>
-	public vote(
-		voter: string,
-		author: string,
-		permlink: string,
-		weight: string | number,
-		cb?: CallbackFunction
-	): Promise<SendResponse> {
-		const params = {
-			voter,
-			author,
-			permlink,
-			weight
-		}
-		return this.broadcast([['vote', params]], cb)
-	}
-
-	public comment(
-		parentAuthor: string,
-		parentPermlink: string,
-		author: string,
-		permlink: string,
-		title: string,
-		body: any,
-		jsonMetadata: any
-	): Promise<SendResponse>
-	public comment(
-		parentAuthor: string,
-		parentPermlink: string,
-		author: string,
-		permlink: string,
-		title: string,
-		body: any,
-		jsonMetadata: any,
-		cb: CallbackFunction
-	): Promise<SendResponse>
-	public comment(
-		parentAuthor: string,
-		parentPermlink: string,
-		author: string,
-		permlink: string,
-		title: string,
-		body: any,
-		jsonMetadata: any,
-		cb?: CallbackFunction
-	): Promise<SendResponse> {
-		let json = jsonMetadata
-		if (typeof jsonMetadata !== 'string') {
-			json = JSON.stringify(jsonMetadata)
-		}
-		const params = {
-			parent_author: parentAuthor,
-			parent_permlink: parentPermlink,
-			author,
-			permlink,
-			title,
-			body,
-			json_metadata: json
-		}
-		return this.broadcast([['comment', params]], cb)
-	}
-
-	public deleteComment(author: string, permlink: string): Promise<SendResponse>
-	public deleteComment(author: string, permlink: string, cb: CallbackFunction): Promise<SendResponse>
-	public deleteComment(author: string, permlink: string, cb?: CallbackFunction): Promise<SendResponse> {
-		const params = {
-			author,
-			permlink
-		}
-		return this.broadcast([['delete_comment', params]], cb)
-	}
-
-	public customJson(requiredAuths: any, requiredPostingAuths: any, id: string, json: any): Promise<SendResponse>
-	public customJson(
-		requiredAuths: any,
-		requiredPostingAuths: any,
-		id: string,
-		json: any,
-		cb: CallbackFunction
-	): Promise<SendResponse>
-	public customJson(
-		requiredAuths: any,
-		requiredPostingAuths: any,
-		id: string,
-		json: any,
-		cb?: CallbackFunction
-	): Promise<SendResponse> {
-		const params = {
-			required_auths: requiredAuths,
-			required_posting_auths: requiredPostingAuths,
-			id,
-			json
-		}
-		return this.broadcast([['custom_json', params]], cb)
-	}
-
-	public reblog(account: string, author: string, permlink: string): Promise<SendResponse>
-	public reblog(account: string, author: string, permlink: string, cb: CallbackFunction): Promise<SendResponse>
-	public reblog(account: string, author: string, permlink: string, cb?: CallbackFunction): Promise<SendResponse> {
-		const json = ['reblog', { account, author, permlink }]
-		return this.customJson([], [account], 'follow', JSON.stringify(json), cb)
-	}
-
-	public follow(follower: string, following: string): Promise<SendResponse>
-	public follow(follower: string, following: string, cb: CallbackFunction): Promise<SendResponse>
-	public follow(follower: string, following: string, cb?: CallbackFunction): Promise<SendResponse> {
-		const json = ['follow', { follower, following, what: ['blog'] }]
-		return this.customJson([], [follower], 'follow', JSON.stringify(json), cb)
-	}
-
-	public unfollow(unfollower: string, unfollowing: string): Promise<SendResponse>
-	public unfollow(unfollower: string, unfollowing: string, cb: CallbackFunction): Promise<SendResponse>
-	public unfollow(unfollower: string, unfollowing: string, cb?: CallbackFunction): Promise<SendResponse> {
-		const json = ['follow', { follower: unfollower, following: unfollowing, what: <string[]>[] }]
-		return this.customJson([], [unfollower], 'follow', JSON.stringify(json), cb)
-	}
-
-	public ignore(follower: string, following: string): Promise<SendResponse>
-	public ignore(follower: string, following: string, cb: CallbackFunction): Promise<SendResponse>
-	public ignore(follower: string, following: string, cb?: CallbackFunction): Promise<SendResponse> {
-		const json = ['follow', { follower, following, what: ['ignore'] }]
-		return this.customJson([], [follower], 'follow', JSON.stringify(json), cb)
-	}
-
-	public claimRewardBalance(
-		account: string,
-		rewardHive: string,
-		rewardHbd: string,
-		rewardVests: string,
-	): Promise<SendResponse>
-	public claimRewardBalance(
-		account: string,
-		rewardHive: string,
-		rewardHbd: string,
-		rewardVests: string,
-		cb: CallbackFunction
-	): Promise<SendResponse>
-	public claimRewardBalance(
-		account: string,
-		rewardHive: string,
-		rewardHbd: string,
-		rewardVests: string,
-		cb?: CallbackFunction
-	): Promise<SendResponse> {
-		const params = {
-			account,
-			reward_hive: rewardHive,
-			reward_hbd: rewardHbd,
-			reward_vests: rewardVests
-		}
-		return this.broadcast([['claim_reward_balance', params]], cb)
-	}
-
-	public async revokeToken(): Promise<Client>
-	public async revokeToken(cb: CallbackFunction): Promise<Client>
-	public async revokeToken(cb?: CallbackFunction): Promise<Client> {
-		await this.send('oauth2/token/revoke', 'POST', { token: this.accessToken }, cb)
-		return this.removeAccessToken()
-	}
-
-	public updateUserMetadata(metadata: any): Promise<SendResponse>
-	public updateUserMetadata(metadata: any, cb: CallbackFunction): Promise<SendResponse>
-	public updateUserMetadata(metadata: any = {}, cb?: CallbackFunction): Promise<SendResponse> {
-		console.warn('The function "updateUserMetadata" is deprecated.')
-		return this.send('me', 'PUT', { user_metadata: metadata }, cb)
-	}
-
-	public async send(route: string, method: string, body: any): Promise<SendResponse>
-	public async send(route: string, method: string, body: any, cb: CallbackFunction): Promise<SendResponse>
-	public async send(route: string, method: string, body: any, cb?: CallbackFunction): Promise<SendResponse> {
-		const url = `${this.apiURL}/api/${route}`
-
-		if (!cb) {
-			return this.makeRequest(url, method, body)
-		}
-
-		try {
-			const json = await this.makeRequest(url, method, body)
-			return cb(null, json)
-		} catch (failureResponse) {
-			return cb(failureResponse, null)
-		}
-	}
-
-	public broadcast(operations: Operation[]): Promise<SendResponse>
-	public broadcast(operations: Operation[], cb: CallbackFunction): Promise<SendResponse>
-	public broadcast(operations: Operation[], cb?: CallbackFunction): Promise<SendResponse> {
-		return this.send('broadcast', 'POST', { operations }, cb)
-	}
-
-	private async makeRequest(url: string, method: string, body: any): Promise<SendResponse> {
-		const response = await fetch(url, {
-			method,
-			headers: {
-				Accept: 'application/json, text/plain, */*',
-				'Content-Type': 'application/json',
-				Authorization: this.accessToken,
-			},
-			body: JSON.stringify(body),
-		})
-
-		const json = await response.json()
-
-		if (response.status !== 200 || json.error) {
-			throw json
-		}
-
-		return json
-	}
-}

package/src/consts/api-url.const.ts

@@ -1 +0,0 @@
-export const API_URL = 'https://hivesigner.com'

package/src/consts/base-url.const.ts

@@ -1 +0,0 @@
-export const BASE_URL = 'https://hivesigner.com'

package/src/consts/beta-url.const.ts

@@ -1 +0,0 @@
-export const BETA_URL = 'https://hivesigner.com'

package/src/consts/index.ts

@@ -1,3 +0,0 @@
-export * from './api-url.const'
-export * from './base-url.const'
-export * from './beta-url.const'

package/src/default-import.spec.ts

@@ -1,10 +0,0 @@
-import hivesigner from '../lib/index'
-
-describe('Testing default import', function () {
-  it('should contain Client class', function () {
-    expect(hivesigner.Client).toBeTruthy()
-
-    const client = new hivesigner.Client({})
-    expect(client).toBeInstanceOf(hivesigner.Client)
-  })
-})

package/src/factories/index.ts

@@ -1 +0,0 @@
-export * from './initialize.factory'

package/src/factories/initialize.factory.spec.ts

@@ -1,9 +0,0 @@
-import { Initialize } from './initialize.factory'
-import { ClientConfig } from '../types'
-import { Client } from '../client'
-
-describe('Initialize Client factory', function () {
-	it('should create client instance', function () {
-		expect(Initialize({} as ClientConfig)).toBeInstanceOf(Client)
-	})
-})

package/src/factories/initialize.factory.ts

@@ -1,7 +0,0 @@
-import { ClientConfig } from '../types'
-import { Client } from '../client'
-
-export function Initialize(config: ClientConfig): Client {
-	console.warn('The function "Initialize" is deprecated, please use the class "Client" instead.')
-	return new Client(config)
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export * from './client'
-export * from './methods'
-export * from './factories'
-
-import { Client } from './client'
-import { Initialize } from './factories'
-import { sendTransaction, sendOperations, sendOperation, sign } from './methods'
-
-export default {
-	Client,
-	Initialize,
-	sendTransaction,
-	sendOperations,
-	sendOperation,
-	sign
-}

package/src/methods/index.ts

@@ -1,4 +0,0 @@
-export * from './sign.method'
-export * from './send-operation.method'
-export * from './send-operations.method'
-export * from './send-transaction.method'

package/src/methods/send-operation.method.spec.ts

@@ -1,47 +0,0 @@
-import { Operation } from '@hiveio/dhive'
-import * as hive from 'hive-uri'
-import * as utilities from '../utilities'
-import { CallbackFunction } from '../types'
-import { BETA_URL } from '../consts'
-import { sendOperation } from './send-operation.method'
-
-jest.mock('../utilities')
-jest.mock('hive-uri')
-
-describe('Send operation method', function () {
-	let op: Operation
-	let params: hive.Parameters
-	let cb: CallbackFunction
-	let encodeOpMock: jest.Mock
-	let isBrowserMock: jest.Mock
-
-	beforeEach(() => {
-		op = {} as Operation
-		params = {}
-		cb = () => {}
-
-		(window as { open: () => void }).open = jest.fn()
-		encodeOpMock = hive.encodeOp as jest.Mock
-		encodeOpMock.mockReturnValue('hive://')
-
-		isBrowserMock = utilities.isBrowser as jest.Mock
-		isBrowserMock.mockReturnValue(false)
-	})
-
-	it('should call call window open if its browser and has callback', function () {
-		(window.open as jest.Mock).mockReturnValue({ focus: () => {} })
-		isBrowserMock.mockReturnValue(true)
-
-		sendOperation(op, params, cb)
-		expect(window.open).toHaveBeenCalledWith(`${BETA_URL}/`, '_blank')
-	})
-
-	it('should return url if its not browser', function () {
-		expect(sendOperation(op, params, cb)).toBe(`${BETA_URL}/`)
-	})
-
-	it('should return url if there is no callback', function () {
-		cb = null
-		expect(sendOperation(op, params, cb)).toBe(`${BETA_URL}/`)
-	})
-})

package/src/methods/send-operation.method.ts

@@ -1,15 +0,0 @@
-import { BETA_URL } from '../consts'
-import { encodeOp, Parameters } from 'hive-uri'
-import { isBrowser } from '../utilities'
-import { CallbackFunction } from '../types'
-import { Operation } from '@hiveio/dhive'
-
-export function sendOperation(op: Operation, params: Parameters, cb: CallbackFunction): string | void {
-	const uri = encodeOp(op, params)
-	const webUrl = uri.replace('hive://', `${BETA_URL}/`)
-	if (cb && isBrowser()) {
-		const win = window.open(webUrl, '_blank')
-		return win.focus()
-	}
-	return webUrl
-}

package/src/methods/send-operations.method.spec.ts

@@ -1,47 +0,0 @@
-import { Operation } from '@hiveio/dhive'
-import * as hive from 'hive-uri'
-import * as utilities from '../utilities'
-import { CallbackFunction } from '../types'
-import { BETA_URL } from '../consts'
-import { sendOperations } from './send-operations.method'
-
-jest.mock('../utilities')
-jest.mock('hive-uri')
-
-describe('Send operations method', function () {
-	let ops: Operation[]
-	let params: hive.Parameters
-	let cb: CallbackFunction
-	let encodeOpsMock: jest.Mock
-	let isBrowserMock: jest.Mock
-
-	beforeEach(() => {
-		ops = [] as Operation[]
-		params = {}
-		cb = () => {}
-		(window as { open: () => void }).open = jest.fn()
-
-		encodeOpsMock = hive.encodeOps as jest.Mock
-		encodeOpsMock.mockReturnValue('hive://')
-
-		isBrowserMock = utilities.isBrowser as jest.Mock
-		isBrowserMock.mockReturnValue(false)
-	})
-
-	it('should call call window open if its browser and has callback', function () {
-		(window.open as jest.Mock).mockReturnValue({ focus: () => {} })
-		isBrowserMock.mockReturnValue(true)
-
-		sendOperations(ops, params, cb)
-		expect(window.open).toHaveBeenCalledWith(`${BETA_URL}/`, '_blank')
-	})
-
-	it('should return url if its not browser', function () {
-		expect(sendOperations(ops, params, cb)).toBe(`${BETA_URL}/`)
-	})
-
-	it('should return url if there is no callback', function () {
-		cb = null
-		expect(sendOperations(ops, params, cb)).toBe(`${BETA_URL}/`)
-	})
-})

package/src/methods/send-operations.method.ts

@@ -1,15 +0,0 @@
-import { encodeOps, Parameters } from 'hive-uri'
-import { isBrowser } from '../utilities'
-import { BETA_URL } from '../consts'
-import { CallbackFunction } from '../types'
-import { Operation } from '@hiveio/dhive'
-
-export function sendOperations(ops: Operation[], params: Parameters, cb: CallbackFunction): string | void {
-	const uri = encodeOps(ops, params)
-	const webUrl = uri.replace('hive://', `${BETA_URL}/`)
-	if (cb && isBrowser()) {
-		const win = window.open(webUrl, '_blank')
-		return win.focus()
-	}
-	return webUrl
-}

package/src/methods/send-transaction.method.spec.ts

@@ -1,47 +0,0 @@
-import { sendTransaction } from './send-transaction.method'
-import { Transaction } from '@hiveio/dhive'
-import * as hive from 'hive-uri'
-import * as utilities from '../utilities'
-import { CallbackFunction } from '../types'
-import { BETA_URL } from '../consts'
-
-jest.mock('../utilities')
-jest.mock('hive-uri')
-
-describe('Send transaction method', function () {
-	let tx: Transaction
-	let params: hive.Parameters
-	let cb: CallbackFunction
-	let encodeTxMock: jest.Mock
-	let isBrowserMock: jest.Mock
-
-	beforeEach(() => {
-		tx = {} as Transaction
-		params = {}
-		cb = () => {}
-		(window as { open: () => void }).open = jest.fn()
-
-		encodeTxMock = hive.encodeTx as jest.Mock
-		encodeTxMock.mockReturnValue('hive://')
-
-		isBrowserMock = utilities.isBrowser as jest.Mock
-		isBrowserMock.mockReturnValue(false)
-	})
-
-	it('should call call window open if its browser and has callback', function () {
-		(window.open as jest.Mock).mockReturnValue({ focus: () => {} })
-		isBrowserMock.mockReturnValue(true)
-
-		sendTransaction(tx, params, cb)
-		expect(window.open).toHaveBeenCalledWith(`${BETA_URL}/`, '_blank')
-	})
-
-	it('should return url if its not browser', function () {
-		expect(sendTransaction(tx, params, cb)).toBe(`${BETA_URL}/`)
-	})
-
-	it('should return url if there is no callback', function () {
-		cb = null
-		expect(sendTransaction(tx, params, cb)).toBe(`${BETA_URL}/`)
-	})
-})

package/src/methods/send-transaction.method.ts

@@ -1,15 +0,0 @@
-import { encodeTx, Parameters } from 'hive-uri'
-import { BETA_URL } from '../consts'
-import { isBrowser } from '../utilities'
-import { CallbackFunction } from '../types'
-import { Transaction } from '@hiveio/dhive'
-
-export function sendTransaction(tx: Transaction, params: Parameters, cb: CallbackFunction): string | void {
-	const uri = encodeTx(tx, params)
-	const webUrl = uri.replace('hive://', `${BETA_URL}/`)
-	if (cb && isBrowser()) {
-		const win = window.open(webUrl, '_blank')
-		return win.focus()
-	}
-	return webUrl
-}

package/src/methods/sign.method.spec.ts

@@ -1,60 +0,0 @@
-import { sign } from './sign.method'
-import { BASE_URL } from '../consts'
-
-describe('Sign method', function () {
-	let name: string
-	let params: Record<string, string | number | boolean>
-	let redirectUri: string
-
-	beforeEach(() => {
-		name = ''
-		params = {}
-		redirectUri = ''
-	})
-
-	it('should return url if given correct parameters', function () {
-		name = 'name'
-		params = { one: 'one', two: 'two' }
-		redirectUri = 'https://example.com'
-
-		expect(sign(name, params, redirectUri))
-			.toBe(`${BASE_URL}/sign/name?one=one&two=two&redirect_uri=https%3A%2F%2Fexample.com`)
-	})
-
-	it('should return url if given correct parameters without redirect uri', function () {
-		name = 'name'
-		params = { one: 'one', two: 'two' }
-		redirectUri = null
-
-		expect(sign(name, params, redirectUri)).toBe(`${BASE_URL}/sign/name?one=one&two=two`)
-	})
-
-	it('should return url if given correct name and empty parameters', function () {
-		name = 'name'
-
-		expect(sign(name, params, redirectUri)).toBe(`${BASE_URL}/sign/name?`)
-	})
-
-	it('should return error if given incorrect name', function () {
-		name = null
-
-		expect(sign(name, params, redirectUri)).toStrictEqual({
-			error: 'invalid_request',
-			error_description: 'Request has an invalid format'
-		})
-	})
-
-	it('should return error if given incorrect params', function () {
-		params = undefined
-		expect(sign(name, params, redirectUri)).toStrictEqual({
-			error: 'invalid_request',
-			error_description: 'Request has an invalid format'
-		})
-
-		params = undefined
-		expect(sign(name, params, redirectUri)).toStrictEqual({
-			error: 'invalid_request',
-			error_description: 'Request has an invalid format'
-		})
-	})
-})

package/src/methods/sign.method.ts

@@ -1,22 +0,0 @@
-import { BASE_URL } from '../consts'
-import { SignErrors } from '../types'
-
-export function sign(
-	name: string,
-	params: Record<string, string | number | boolean>,
-	redirectUri: string
-): string | SignErrors {
-	console.warn('The function "sign" is deprecated.')
-	if (typeof name !== 'string' || typeof params !== 'object' || params === null) {
-		return {
-			error: 'invalid_request',
-			error_description: 'Request has an invalid format'
-		}
-	}
-	let url = `${BASE_URL}/sign/${name}?`
-	url += Object.keys(params)
-		.map(key => `${key}=${encodeURIComponent(params[key])}`)
-		.join('&')
-	url += redirectUri ? `&redirect_uri=${encodeURIComponent(redirectUri)}` : ''
-	return url
-}

package/src/modules-import.spec.ts

@@ -1,11 +0,0 @@
-// @ts-ignore
-import { Client } from '../lib/index'
-
-describe('Testing module imports', function () {
-  it('should contain Client class', function () {
-    expect(Client).toBeTruthy()
-
-    const client = new Client({})
-    expect(client).toBeInstanceOf(Client)
-  })
-})