9647368506

Committed 24 Jun 2024 02:38PM UTC coverage: 0.36% (-14.5%) from 14.895%

Build # 9647368506

Build Type

Pull #8229

github

Committed by

web-flow

Commit Message

Merge 51d3b076c into 3dc674aab

Pull Request Pull Request #8229: Added indices to profile/address search

Run Details

66 of 15852 branches covered (0.42%)

Branch coverage included in aggregate %.

0 of 5 new or added lines in 1 file covered. (0.0%)

3516 existing lines in 313 files now uncovered.

103 of 31123 relevant lines covered (0.33%)

0.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/packages/commonwealth/shared/utils.ts

import { AccessLevel, RoleObject } from '@hicommonwealth/shared';
import { Dec, IntPretty } from '@keplr-wallet/unit';
import { isHex, isU8a } from '@polkadot/util';
import {
  checkAddress,
  decodeAddress,
  encodeAddress,
} from '@polkadot/util-crypto';

export const slugifyPreserveDashes = (str: string): string => {
  // Remove any character that isn't a alphanumeric character, a
  // space, or a dash, and then replace any sequence of spaces with a single dash.

  // return str
  //   .toLowerCase()
  //   .trim()
  //   .replace(/[^A-Za-z0-9]+/g, '-');

  return str
    .replace(/[^A-Za-z0-9 -]/g, '')
    .replace(/(\s|-)+/g, '-')
    .replace(/^-|-$/g, '')
    .toLowerCase();
};

export const getThreadUrlWithoutObject = (
  proposalCommunity,
  proposalId,
  comment?,
) => {
  const aId = proposalCommunity;
  const tId = proposalId;
  const cId = comment ? `?comment=${comment.id}` : '';

  return process.env.NODE_ENV === 'production'
    ? `https://commonwealth.im/${aId}/discussion/${tId}${cId}`
    : `http://localhost:8080/${aId}/discussion/${tId}${cId}`;
};

// WARN: Using process.env to avoid webpack failures
export const getCommunityUrl = (community: string): string => {
  return process.env.NODE_ENV === 'production'
    ? `https://commonwealth.im/${community}`
    : `http://localhost:8080/${community}`;
};

export const smartTrim = (text, maxLength = 200) => {
  if (text.length > maxLength) {
    const smartTrimmedText = text.slice(0, maxLength).replace(/\W+$/, '');
    if (smartTrimmedText.length === 0) return `${text.slice(0, maxLength)}...`;
    return `${smartTrimmedText}...`;
  } else {
    return text;
  }
};

export const validURL = (str) => {
  const pattern = new RegExp(
    '^(https?:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+:@]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$',
    'i',
  ); // fragment locator
  return !!pattern.test(str);
};

export const urlHasValidHTTPPrefix = (url: string) => {
  return url.indexOf('http://') === 0 || url.indexOf('https://') === 0;
};

export const preprocessQuillDeltaForRendering = (nodes) => {
  // split up nodes at line boundaries
  const lines = [];
  for (const node of nodes) {
    if (typeof node.insert === 'string') {
      const matches = node.insert.match(/[^\n]+\n?|\n/g);
      (matches || []).forEach((line) => {
        // @ts-expect-error StrictNullChecks
        lines.push({ attributes: node.attributes, insert: line });
      });
    } else {
      // @ts-expect-error StrictNullChecks
      lines.push(node);
    }
  }
  // group nodes under parents
  const result = [];
  let parent = { children: [], attributes: undefined };
  for (const node of lines) {
    // @ts-expect-error StrictNullChecks
    if (typeof node.insert === 'string' && node.insert.endsWith('\n')) {
      // @ts-expect-error StrictNullChecks
      parent.attributes = node.attributes;
      // concatenate code-block node parents together, keeping newlines
      if (
        result.length > 0 &&
        // @ts-expect-error StrictNullChecks
        result[result.length - 1].attributes &&
        parent.attributes &&
        parent.attributes['code-block'] &&
        // @ts-expect-error StrictNullChecks
        result[result.length - 1].attributes['code-block']
      ) {
        // @ts-expect-error StrictNullChecks
        parent.children.push({ insert: node.insert });
        // @ts-expect-error StrictNullChecks
        result[result.length - 1].children = result[
          result.length - 1
          // @ts-expect-error StrictNullChecks
        ].children.concat(parent.children);
      } else {
        // @ts-expect-error StrictNullChecks
        parent.children.push({ insert: node.insert });
        // @ts-expect-error StrictNullChecks
        result.push(parent);
      }
      parent = { children: [], attributes: undefined };
    } else {
      parent.children.push(node);
    }
  }
  // If there was no \n at the end of the document, we need to push whatever remains in `parent`
  // onto the result. This may happen if we are rendering a truncated Quill document
  if (parent.children.length > 0) {
    // @ts-expect-error StrictNullChecks
    result.push(parent);
  }

  // trim empty newlines at end of document
  while (
    result.length &&
    // @ts-expect-error StrictNullChecks
    result[result.length - 1].children.length === 1 &&
    // @ts-expect-error StrictNullChecks
    typeof result[result.length - 1].children[0].insert === 'string' &&
    // @ts-expect-error StrictNullChecks
    result[result.length - 1].children[0].insert === '\n' &&
    // @ts-expect-error StrictNullChecks
    result[result.length - 1].children[0].attributes === undefined
  ) {
    result.pop();
  }

  return result;
};

export const renderQuillDeltaToText = (delta, paragraphSeparator = '\n\n') => {
  return preprocessQuillDeltaForRendering(delta.ops)
    .map((parent) => {
      // @ts-expect-error StrictNullChecks
      return parent.children
        .map((child) => {
          if (typeof child.insert === 'string')
            return child.insert.trimRight('\n');
          if (child.insert?.image) return '(image)';
          if (child.insert?.twitter) return '(tweet)';
          if (child.insert?.video) return '(video)';
          return '';
        })
        .filter((child) => !!child)
        .join(' ')
        .replace(/  +/g, ' '); // remove multiple spaces
    })
    .filter((parent) => !!parent)
    .join(paragraphSeparator);
};

export function formatAddressShort(
  address: string,
  chain?: string,
  includeEllipsis?: boolean,
  maxCharLength?: number,
  prefix?: string,
) {
  if (!address) return;
  if (chain === 'near') {
    return `@${address}`;
  } else if (prefix && !maxCharLength) {
    if (!includeEllipsis) return address;
    const totalLength = address.length;
    return `${address.slice(0, prefix.length + 3)}...${address.slice(
      totalLength - 4,
      totalLength,
    )}`;
  } else {
    return `${address.slice(0, maxCharLength || 5)}${
      includeEllipsis ? '…' : ''
    }`;
  }
}

export const addressSwapper = (options: {
  address: string;
  currentPrefix: number;
}): string => {
  if (!options.address) throw new Error('No address provided to swap');

  if (!options.currentPrefix) return options.address;

  if (isU8a(options.address) || isHex(options.address)) {
    throw new Error('address not in SS58 format');
  }

  // check if it is valid as an address
  let decodedAddress: Uint8Array;

  try {
    decodedAddress = decodeAddress(options.address);
  } catch (e) {
    throw new Error('failed to decode address');
  }

  // check if it is valid with the current prefix & reencode if needed
  const [valid] = checkAddress(options.address, options.currentPrefix);

  if (!valid) {
    try {
      return encodeAddress(decodedAddress, options.currentPrefix);
    } catch (e) {
      throw new Error('failed to reencode address');
    }
  } else {
    return options.address;
  }
};

export function aggregatePermissions(
  roles: RoleObject[],
  chain_permissions: { allow: number; deny: number },
) {
  const ORDER: AccessLevel[] = [
    AccessLevel.Member,
    AccessLevel.Moderator,
    AccessLevel.Admin,
  ];

  function compare(o1: RoleObject, o2: RoleObject) {
    return ORDER.indexOf(o1.permission) - ORDER.indexOf(o2.permission);
  }

  roles = roles.sort(compare);

  const permissionsAllowDeny: Array<{
    allow: number;
    deny: number;
  }> = roles.map(({ allow, deny }) => ({ allow, deny }));

  // add chain default permissions to beginning of permissions array
  permissionsAllowDeny.unshift(chain_permissions);

  // compute permissions
  return BigInt(0); //bandaid fix. always allow permissions due to removing functionality.
}

/**
 * Convert Cosmos-style minimal denom amount to readable full-denom amount
 * Example 7000000 uosmo -> 7 OSMO
 * Example 8000000000000000000 aevmos -> 8 EVMOS
 */
export function minimalToNaturalDenom(
  amount?: string | number,
  decimals?: number,
): string {
  if (!amount || !decimals) return '0';
  const intPretty = new IntPretty(
    new Dec(amount.toString()),
  ).moveDecimalPointLeft(decimals);

  // return full decimal precision and let the UI handle rounding
  return intPretty.toDec().toString(decimals);
}

/**
 * Convert readable full-denom amount to minimal denom amount (BigInt)
 * Example 8 OSMO -> 8000000 uosmo
 * Example 8 EVMOS -> 8000000000000000000 aevmos
 * Intended for Cosmos use (decimals usually 6 or 18)
 */
export function naturalDenomToMinimal(
  naturalAmount?: string | number,
  decimals?: number,
): string {
  if (!naturalAmount || !decimals) return '0';
  const intPretty = new IntPretty(
    new Dec(naturalAmount.toString()),
  ).moveDecimalPointRight(decimals);

  // 0 decimal places because this is max precision for the chain
  return intPretty.toDec().toString(0);
}

/**
 * Convert Cosmos bech32 address to a hexadecimal string
 * hex is used as a common identifier for addresses across chains.
 * This allows us to achieve One Signer, One Account
 *
 * Example:
 * bech32ToHex('osmo18q3tlnx8vguv2fadqslm7x59ejauvsmnhltgq6') => '3822bfccc76238c527ad043fbf1a85ccbbc64373'
 * bech32ToHex('cosmos18q3tlnx8vguv2fadqslm7x59ejauvsmnlycckg') => '3822bfccc76238c527ad043fbf1a85ccbbc64373' (same)
 *
 * Caveat: Ethermint addresses will share a hex, but it will differ from
 * their siblings on standard Cosmos derivation paths.
 * e.g. evmos hex != osmo hex, but evmos hex == inj hex
 */
export async function bech32ToHex(address: string) {
  const { toHex, fromBech32 } = await import('@cosmjs/encoding');
  try {
    const encodedData = fromBech32(address).data;
    return toHex(encodedData);
  } catch (e) {
    console.log(`Error converting bech32 to hex: ${e}. Hex was not generated.`);
  }
}

1	import { AccessLevel, RoleObject } from '@hicommonwealth/shared';
2	import { Dec, IntPretty } from '@keplr-wallet/unit';
3	import { isHex, isU8a } from '@polkadot/util';
4	import {
5	checkAddress,
6	decodeAddress,
7	encodeAddress,
8	} from '@polkadot/util-crypto';
9
UNCOV 10	export const slugifyPreserveDashes = (str: string): string => {	×
11	// Remove any character that isn't a alphanumeric character, a
12	// space, or a dash, and then replace any sequence of spaces with a single dash.
13
14	// return str
15	// .toLowerCase()
16	// .trim()
17	// .replace(/[^A-Za-z0-9]+/g, '-');
18
19	return str	×
20	.replace(/[^A-Za-z0-9 -]/g, '')
21	.replace(/(\s\|-)+/g, '-')
22	.replace(/^-\|-$/g, '')
23	.toLowerCase();
24	};
25
UNCOV 26	export const getThreadUrlWithoutObject = (	×
27	proposalCommunity,
28	proposalId,
29	comment?,
30	) => {
31	const aId = proposalCommunity;	×
32	const tId = proposalId;	×
33	const cId = comment ? `?comment=${comment.id}` : '';	×
34
35	return process.env.NODE_ENV === 'production'	×
36	? `https://commonwealth.im/${aId}/discussion/${tId}${cId}`
37	: `http://localhost:8080/${aId}/discussion/${tId}${cId}`;
38	};
39
40	// WARN: Using process.env to avoid webpack failures
UNCOV 41	export const getCommunityUrl = (community: string): string => {	×
UNCOV 42	return process.env.NODE_ENV === 'production'	×
43	? `https://commonwealth.im/${community}`
44	: `http://localhost:8080/${community}`;
45	};
46
UNCOV 47	export const smartTrim = (text, maxLength = 200) => {	×
UNCOV 48	if (text.length > maxLength) {	×
49	const smartTrimmedText = text.slice(0, maxLength).replace(/\W+$/, '');	×
50	if (smartTrimmedText.length === 0) return `${text.slice(0, maxLength)}...`;	×
51	return `${smartTrimmedText}...`;	×
52	} else {
UNCOV 53	return text;	×
54	}
55	};
56
UNCOV 57	export const validURL = (str) => {	×
58	const pattern = new RegExp(	×
59	'^(https?:\\/\\/)?' + // protocol
60	'((([a-z\\d]([a-z\\d-][a-z\\d]))\\.)+[a-z]{2,}\|' + // domain name
61	'((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
62	'(\\:\\d+)?(\\/[-a-z\\d%_.~+:@])' + // port and path
63	'(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
64	'(\\#[-a-z\\d_]*)?$',
65	'i',
66	); // fragment locator
67	return !!pattern.test(str);	×
68	};
69
UNCOV 70	export const urlHasValidHTTPPrefix = (url: string) => {	×
UNCOV 71	return url.indexOf('http://') === 0 \|\| url.indexOf('https://') === 0;	×
72	};
73
UNCOV 74	export const preprocessQuillDeltaForRendering = (nodes) => {	×
75	// split up nodes at line boundaries
76	const lines = [];	×
77	for (const node of nodes) {	×
78	if (typeof node.insert === 'string') {	×
79	const matches = node.insert.match(/[^\n]+\n?\|\n/g);	×
80	(matches \|\| []).forEach((line) => {	×
81	// @ts-expect-error StrictNullChecks
82	lines.push({ attributes: node.attributes, insert: line });	×
83	});
84	} else {
85	// @ts-expect-error StrictNullChecks
86	lines.push(node);	×
87	}
88	}
89	// group nodes under parents
90	const result = [];	×
91	let parent = { children: [], attributes: undefined };	×
92	for (const node of lines) {	×
93	// @ts-expect-error StrictNullChecks
94	if (typeof node.insert === 'string' && node.insert.endsWith('\n')) {	×
95	// @ts-expect-error StrictNullChecks
96	parent.attributes = node.attributes;	×
97	// concatenate code-block node parents together, keeping newlines
98	if (	×
99	result.length > 0 &&	×
100	// @ts-expect-error StrictNullChecks
101	result[result.length - 1].attributes &&
102	parent.attributes &&
103	parent.attributes['code-block'] &&
104	// @ts-expect-error StrictNullChecks
105	result[result.length - 1].attributes['code-block']
106	) {
107	// @ts-expect-error StrictNullChecks
108	parent.children.push({ insert: node.insert });	×
109	// @ts-expect-error StrictNullChecks
110	result[result.length - 1].children = result[	×
111	result.length - 1
112	// @ts-expect-error StrictNullChecks
113	].children.concat(parent.children);
114	} else {
115	// @ts-expect-error StrictNullChecks
116	parent.children.push({ insert: node.insert });	×
117	// @ts-expect-error StrictNullChecks
118	result.push(parent);	×
119	}
120	parent = { children: [], attributes: undefined };	×
121	} else {
122	parent.children.push(node);	×
123	}
124	}
125	// If there was no \n at the end of the document, we need to push whatever remains in `parent`
126	// onto the result. This may happen if we are rendering a truncated Quill document
127	if (parent.children.length > 0) {	×
128	// @ts-expect-error StrictNullChecks
129	result.push(parent);	×
130	}
131
132	// trim empty newlines at end of document
133	while (	×
134	result.length &&	×
135	// @ts-expect-error StrictNullChecks
136	result[result.length - 1].children.length === 1 &&
137	// @ts-expect-error StrictNullChecks
138	typeof result[result.length - 1].children[0].insert === 'string' &&
139	// @ts-expect-error StrictNullChecks
140	result[result.length - 1].children[0].insert === '\n' &&
141	// @ts-expect-error StrictNullChecks
142	result[result.length - 1].children[0].attributes === undefined
143	) {
144	result.pop();	×
145	}
146
147	return result;	×
148	};
149
UNCOV 150	export const renderQuillDeltaToText = (delta, paragraphSeparator = '\n\n') => {	×
151	return preprocessQuillDeltaForRendering(delta.ops)	×
152	.map((parent) => {
153	// @ts-expect-error StrictNullChecks
154	return parent.children	×
155	.map((child) => {
156	if (typeof child.insert === 'string')	×
157	return child.insert.trimRight('\n');	×
158	if (child.insert?.image) return '(image)';	×
159	if (child.insert?.twitter) return '(tweet)';	×
160	if (child.insert?.video) return '(video)';	×
161	return '';	×
162	})
163	.filter((child) => !!child)	×
164	.join(' ')
165	.replace(/ +/g, ' '); // remove multiple spaces
166	})
167	.filter((parent) => !!parent)	×
168	.join(paragraphSeparator);
169	};
170
171	export function formatAddressShort(
172	address: string,
173	chain?: string,
174	includeEllipsis?: boolean,
175	maxCharLength?: number,
176	prefix?: string,
177	) {
UNCOV 178	if (!address) return;	×
UNCOV 179	if (chain === 'near') {	×
180	return `@${address}`;	×
UNCOV 181	} else if (prefix && !maxCharLength) {	×
182	if (!includeEllipsis) return address;	×
183	const totalLength = address.length;	×
184	return `${address.slice(0, prefix.length + 3)}...${address.slice(	×
185	totalLength - 4,
186	totalLength,
187	)}`;
188	} else {
UNCOV 189	return `${address.slice(0, maxCharLength \|\| 5)}${	×
190	includeEllipsis ? '…' : ''	×
191	}`;
192	}
193	}
194
UNCOV 195	export const addressSwapper = (options: {	×
196	address: string;
197	currentPrefix: number;
198	}): string => {
199	if (!options.address) throw new Error('No address provided to swap');	×
200
201	if (!options.currentPrefix) return options.address;	×
202
203	if (isU8a(options.address) \|\| isHex(options.address)) {	×
204	throw new Error('address not in SS58 format');	×
205	}
206
207	// check if it is valid as an address
208	let decodedAddress: Uint8Array;
209
210	try {	×
211	decodedAddress = decodeAddress(options.address);	×
212	} catch (e) {
213	throw new Error('failed to decode address');	×
214	}
215
216	// check if it is valid with the current prefix & reencode if needed
217	const [valid] = checkAddress(options.address, options.currentPrefix);	×
218
219	if (!valid) {	×
220	try {	×
221	return encodeAddress(decodedAddress, options.currentPrefix);	×
222	} catch (e) {
223	throw new Error('failed to reencode address');	×
224	}
225	} else {
226	return options.address;	×
227	}
228	};
229
230	export function aggregatePermissions(
231	roles: RoleObject[],
232	chain_permissions: { allow: number; deny: number },
233	) {
234	const ORDER: AccessLevel[] = [	×
235	AccessLevel.Member,
236	AccessLevel.Moderator,
237	AccessLevel.Admin,
238	];
239
240	function compare(o1: RoleObject, o2: RoleObject) {
241	return ORDER.indexOf(o1.permission) - ORDER.indexOf(o2.permission);	×
242	}
243
244	roles = roles.sort(compare);	×
245
246	const permissionsAllowDeny: Array<{
247	allow: number;
248	deny: number;
249	}> = roles.map(({ allow, deny }) => ({ allow, deny }));	×
250
251	// add chain default permissions to beginning of permissions array
252	permissionsAllowDeny.unshift(chain_permissions);	×
253
254	// compute permissions
255	return BigInt(0); //bandaid fix. always allow permissions due to removing functionality.	×
256	}
257
258	/**
259	* Convert Cosmos-style minimal denom amount to readable full-denom amount
260	* Example 7000000 uosmo -> 7 OSMO
261	* Example 8000000000000000000 aevmos -> 8 EVMOS
262	*/
263	export function minimalToNaturalDenom(
264	amount?: string \| number,
265	decimals?: number,
266	): string {
UNCOV 267	if (!amount \|\| !decimals) return '0';	×
UNCOV 268	const intPretty = new IntPretty(	×
269	new Dec(amount.toString()),
270	).moveDecimalPointLeft(decimals);
271
272	// return full decimal precision and let the UI handle rounding
UNCOV 273	return intPretty.toDec().toString(decimals);	×
274	}
275
276	/**
277	* Convert readable full-denom amount to minimal denom amount (BigInt)
278	* Example 8 OSMO -> 8000000 uosmo
279	* Example 8 EVMOS -> 8000000000000000000 aevmos
280	* Intended for Cosmos use (decimals usually 6 or 18)
281	*/
282	export function naturalDenomToMinimal(
283	naturalAmount?: string \| number,
284	decimals?: number,
285	): string {
UNCOV 286	if (!naturalAmount \|\| !decimals) return '0';	×
UNCOV 287	const intPretty = new IntPretty(	×
288	new Dec(naturalAmount.toString()),
289	).moveDecimalPointRight(decimals);
290
291	// 0 decimal places because this is max precision for the chain
UNCOV 292	return intPretty.toDec().toString(0);	×
293	}
294
295	/**
296	* Convert Cosmos bech32 address to a hexadecimal string
297	* hex is used as a common identifier for addresses across chains.
298	* This allows us to achieve One Signer, One Account
299	*
300	* Example:
301	* bech32ToHex('osmo18q3tlnx8vguv2fadqslm7x59ejauvsmnhltgq6') => '3822bfccc76238c527ad043fbf1a85ccbbc64373'
302	* bech32ToHex('cosmos18q3tlnx8vguv2fadqslm7x59ejauvsmnlycckg') => '3822bfccc76238c527ad043fbf1a85ccbbc64373' (same)
303	*
304	* Caveat: Ethermint addresses will share a hex, but it will differ from
305	* their siblings on standard Cosmos derivation paths.
306	* e.g. evmos hex != osmo hex, but evmos hex == inj hex
307	*/
308	export async function bech32ToHex(address: string) {
UNCOV 309	const { toHex, fromBech32 } = await import('@cosmjs/encoding');	×
UNCOV 310	try {	×
UNCOV 311	const encodedData = fromBech32(address).data;	×
UNCOV 312	return toHex(encodedData);	×
313	} catch (e) {
314	console.log(`Error converting bech32 to hex: ${e}. Hex was not generated.`);	×
315	}
316	}

hicommonwealth / commonwealth / 9647368506

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous