@stack-spot/portal-network 0.184.0 → 0.185.0-beta.1

package/src/utils/string.ts

@@ -1,19 +1,19 @@
-/**
- * If the parameter is a string and it's a valid json, it's formatted with proper line breaks and indentation. If it's not a valid json,
- * the original string is returned.
- * 
- * If the parameter is not a string, a formatted JSON string representation of it is returned.
- * 
- * @param data the data to format.
- * @returns the formatted json string or the original string if not a valid json.
- */
-export function formatJson(data: any): string {
-  if (typeof data === 'string') {
-    try {
-      return JSON.stringify(JSON.parse(data), null, 2)
-    } catch {
-      return data
-    }
-  }
-  return JSON.stringify(data, null, 2)
-}
+/**
+ * If the parameter is a string and it's a valid json, it's formatted with proper line breaks and indentation. If it's not a valid json,
+ * the original string is returned.
+ * 
+ * If the parameter is not a string, a formatted JSON string representation of it is returned.
+ * 
+ * @param data the data to format.
+ * @returns the formatted json string or the original string if not a valid json.
+ */
+export function formatJson(data: any): string {
+  if (typeof data === 'string') {
+    try {
+      return JSON.stringify(JSON.parse(data), null, 2)
+    } catch {
+      return data
+    }
+  }
+  return JSON.stringify(data, null, 2)
+}

package/src/utils/use-extended-list.ts

@@ -1,80 +1,80 @@
-import { useEffect, useRef, useState } from 'react'
-
-type ExtensionMap<T> = Record<string, (item: T) => any>
-
-type Unpromisify<T> = T extends Promise<infer R> ? R : T
-
-type Extension<E extends ExtensionMap<any>> = { [K in keyof E]?: Unpromisify<ReturnType<E[K]>> }
-
-type ItemWithExtensions<T, E extends ExtensionMap<T>> = T & Extension<E>
-
-/**
- * Computes the given extensions for the items in the list passed as parameter. An extension will, most of the times, return a promise,
- * but it can return whatever you'd like.
- * 
- * If the extensions are promises and are still loading, the items won't have the corresponding keys.
- * 
- * Attention: once an extension is calculated for an item, it's never calculated again. An item is identified by the parameter "idProp"
- * (3rd), which is "id" by default.
- * 
- * @example
- * ```
- * const [groups] = accountClient.memberGroups.useInfiniteQuery({ memberId: 'someId' })
- * const extendedGroups = useExtendedList(groups, {
- *   canRemoveMemberFromGroup: group => accountClient.removeMemberFromGroup.isAllowed({ groupId: group.id, memberId: 'someId' }),
- *   title: group => `${group.name} (${group.totalUsers})`,
- * })
- * ```
- * Above, each item in `extendedGroups` will have the properties `canRemoveMemberFromGroup` and `title`, once all permission have been
- * fetched.
- * 
- * @param list the items to compute extensions for.
- * @param extensions an object where the keys are the extension names and the values are functions that return the value of the extension.
- * @param idProp the name of the property that can be used as an id. 'id' by default.
- * @returns an array with 2 items:
- * - [0]: the list with the permission properties.
- * - [1]: true if waiting for a promise, false otherwise.
- */
-export function useExtendedList<T, E extends ExtensionMap<T>>(
-  list: T[], extensions: E, idProp: keyof T,
-): [ItemWithExtensions<T, E>[], boolean]
-export function useExtendedList<T extends { id: string }, E extends ExtensionMap<T>>(
-  list: T[], extensions: E, idProp?: keyof T,
-): [ItemWithExtensions<T, E>[], boolean]
-export function useExtendedList<T, E extends ExtensionMap<T>>(
-  list: T[], extensions: E, idProp = 'id' as keyof T,
-): [ItemWithExtensions<T, E>[], boolean] {
-  const [listWithExtensions, setListWithExtensions] = useState(list as ItemWithExtensions<T, E>[])
-  const [isLoading, setLoading] = useState(true)
-  const extensionMap = useRef(new Map<any, Extension<E>>())
-  const listId = list.map(i => i[idProp]).join(';')
-
-  useEffect(() => {
-    async function update() {
-      setLoading(true)
-      const newList = await Promise.all(list.map(async (item) => {
-        const itemExtensions: Extension<E> = extensionMap.current.get(item[idProp]) ?? {}
-        if (Object.keys(itemExtensions).length === 0) {
-          await Promise.all(Object.keys(extensions).map(async (key: keyof E) => {
-            try {
-              // "await" because it might be a promise
-              itemExtensions[key] = await extensions[key](item)
-            } catch (error) {
-              // eslint-disable-next-line no-console
-              console.error(`Failed to compute extension "${String(key)}" for item with id "${item[idProp]}". It will have undefined as its value, which may cause errors ahead. Caused by the error below:`)
-              // eslint-disable-next-line no-console
-              console.error(error)
-            }
-          }))
-          extensionMap.current.set(item[idProp], itemExtensions)
-        }
-        return { ...item, ...itemExtensions }
-      }))
-      setLoading(false)
-      setListWithExtensions(newList)
-    }
-    update()
-  }, [listId])
-
-  return [listWithExtensions.length ? listWithExtensions : list as ItemWithExtensions<T, E>[], isLoading]
-}
+import { useEffect, useRef, useState } from 'react'
+
+type ExtensionMap<T> = Record<string, (item: T) => any>
+
+type Unpromisify<T> = T extends Promise<infer R> ? R : T
+
+type Extension<E extends ExtensionMap<any>> = { [K in keyof E]?: Unpromisify<ReturnType<E[K]>> }
+
+type ItemWithExtensions<T, E extends ExtensionMap<T>> = T & Extension<E>
+
+/**
+ * Computes the given extensions for the items in the list passed as parameter. An extension will, most of the times, return a promise,
+ * but it can return whatever you'd like.
+ * 
+ * If the extensions are promises and are still loading, the items won't have the corresponding keys.
+ * 
+ * Attention: once an extension is calculated for an item, it's never calculated again. An item is identified by the parameter "idProp"
+ * (3rd), which is "id" by default.
+ * 
+ * @example
+ * ```
+ * const [groups] = accountClient.memberGroups.useInfiniteQuery({ memberId: 'someId' })
+ * const extendedGroups = useExtendedList(groups, {
+ *   canRemoveMemberFromGroup: group => accountClient.removeMemberFromGroup.isAllowed({ groupId: group.id, memberId: 'someId' }),
+ *   title: group => `${group.name} (${group.totalUsers})`,
+ * })
+ * ```
+ * Above, each item in `extendedGroups` will have the properties `canRemoveMemberFromGroup` and `title`, once all permission have been
+ * fetched.
+ * 
+ * @param list the items to compute extensions for.
+ * @param extensions an object where the keys are the extension names and the values are functions that return the value of the extension.
+ * @param idProp the name of the property that can be used as an id. 'id' by default.
+ * @returns an array with 2 items:
+ * - [0]: the list with the permission properties.
+ * - [1]: true if waiting for a promise, false otherwise.
+ */
+export function useExtendedList<T, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp: keyof T,
+): [ItemWithExtensions<T, E>[], boolean]
+export function useExtendedList<T extends { id: string }, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp?: keyof T,
+): [ItemWithExtensions<T, E>[], boolean]
+export function useExtendedList<T, E extends ExtensionMap<T>>(
+  list: T[], extensions: E, idProp = 'id' as keyof T,
+): [ItemWithExtensions<T, E>[], boolean] {
+  const [listWithExtensions, setListWithExtensions] = useState(list as ItemWithExtensions<T, E>[])
+  const [isLoading, setLoading] = useState(true)
+  const extensionMap = useRef(new Map<any, Extension<E>>())
+  const listId = list.map(i => i[idProp]).join(';')
+
+  useEffect(() => {
+    async function update() {
+      setLoading(true)
+      const newList = await Promise.all(list.map(async (item) => {
+        const itemExtensions: Extension<E> = extensionMap.current.get(item[idProp]) ?? {}
+        if (Object.keys(itemExtensions).length === 0) {
+          await Promise.all(Object.keys(extensions).map(async (key: keyof E) => {
+            try {
+              // "await" because it might be a promise
+              itemExtensions[key] = await extensions[key](item)
+            } catch (error) {
+              // eslint-disable-next-line no-console
+              console.error(`Failed to compute extension "${String(key)}" for item with id "${item[idProp]}". It will have undefined as its value, which may cause errors ahead. Caused by the error below:`)
+              // eslint-disable-next-line no-console
+              console.error(error)
+            }
+          }))
+          extensionMap.current.set(item[idProp], itemExtensions)
+        }
+        return { ...item, ...itemExtensions }
+      }))
+      setLoading(false)
+      setListWithExtensions(newList)
+    }
+    update()
+  }, [listId])
+
+  return [listWithExtensions.length ? listWithExtensions : list as ItemWithExtensions<T, E>[], isLoading]
+}

package/src/utils/use-streamed-array.ts

@@ -1,17 +1,17 @@
-import { useEffect, useState } from 'react'
-import { StreamingStatus } from '../types'
-import { StreamedArray } from './StreamedArray'
-
-export function useStreamedArray<T>(stream: StreamedArray<T> | undefined) {
-  const [array, setArray] = useState<T[]>(stream?.getPartialValue() ?? [])
-  const [status, setStatus] = useState<StreamingStatus>(stream?.getStatus() ?? 'pending')
-  useEffect(() => {
-    setArray(stream?.getPartialValue() ?? [])
-    setStatus(stream?.getStatus() ?? 'pending')
-    return stream?.onChange((values) => {
-      setArray(values)
-      setStatus(stream.getStatus())
-    })
-  }, [stream])
-  return [array, status]
-}
+import { useEffect, useState } from 'react'
+import { StreamingStatus } from '../types'
+import { StreamedArray } from './StreamedArray'
+
+export function useStreamedArray<T>(stream: StreamedArray<T> | undefined) {
+  const [array, setArray] = useState<T[]>(stream?.getPartialValue() ?? [])
+  const [status, setStatus] = useState<StreamingStatus>(stream?.getStatus() ?? 'pending')
+  useEffect(() => {
+    setArray(stream?.getPartialValue() ?? [])
+    setStatus(stream?.getStatus() ?? 'pending')
+    return stream?.onChange((values) => {
+      setArray(values)
+      setStatus(stream.getStatus())
+    })
+  }, [stream])
+  return [array, status]
+}

package/tsconfig.build.json

@@ -1,4 +1,4 @@
-{
-  "extends": "./tsconfig",
-  "include": ["src"]
-}
+{
+  "extends": "./tsconfig",
+  "include": ["src"]
+}

package/tsconfig.json

@@ -1,10 +1,10 @@
-{
-  "extends": "../../tsconfig",
-  "compilerOptions": {
-    "module": "ESNext",
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "stripInternal": true,
-  },
-  "include": ["src", "scripts"]
-}
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "module": "ESNext",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "stripInternal": true,
+  },
+  "include": ["src", "scripts"]
+}