@seedprotocol/sdk 0.1.108 → 0.1.109

package/dist/src/getPublishUploads.ts

@@ -0,0 +1,240 @@
+import { Item, ItemProperty } from '@/browser'
+import Transaction from 'arweave/web/lib/transaction'
+import { CreateTransactionInterface } from 'arweave/web'
+import { getArweave } from '@/browser/helpers/arweave'
+import { fs } from '@zenfs/core'
+import { getCorrectId } from '@/browser/helpers'
+import { getSegmentedItemProperties } from '@/browser/helpers/getSegmentedItemProperties'
+import debug from 'debug'
+
+const logger = debug('app:item:getPublishUploads')
+
+export const getContentHash = async (
+  base64: string | null | undefined,
+  uint: Uint8Array | undefined,
+): Promise<string> => {
+  let data
+
+  if (base64 && !uint) {
+    const encoder = new TextEncoder()
+    data = encoder.encode(base64)
+  }
+
+  if (uint) {
+    data = uint
+  }
+
+  // Hash the data with SHA-256
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data as Uint8Array)
+
+  // Convert the ArrayBuffer to a hex string
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+export const prepareArweaveTransaction = async (
+  data: string | Uint8Array,
+  contentHash: string | undefined,
+): Promise<Transaction> => {
+  const transactionData: Partial<CreateTransactionInterface> = {
+    data,
+    tags: [],
+  }
+
+  const tx = await getArweave()!.createTransaction(transactionData)
+
+  if (contentHash) {
+    logger('contentHash', contentHash)
+    logger('adding content hash tag to tx.id:', tx.id)
+    tx.addTag('Content-SHA-256', contentHash)
+  }
+
+  return tx
+}
+export type UploadProperty = {
+  itemProperty: ItemProperty<any>
+  childProperties: ItemProperty<any>[]
+}
+type ChildUploadData = {
+  propertyName: string
+  localStoragePath: string
+}
+const processUploadProperty = async (
+  uploadProperty: UploadProperty,
+  uploads: PublishUpload[],
+  relatedItemProperty?: ItemProperty<any>,
+): Promise<PublishUpload[]> => {
+  const itemProperty = uploadProperty.itemProperty
+
+  const childUploads: ChildUploadData[] = []
+
+  for (const childProperty of uploadProperty.childProperties) {
+    const filePath = childProperty.localStoragePath
+
+    if (!filePath) {
+      throw new Error(
+        `No localStoragePath found for ItemProperty ${childProperty.propertyName}`,
+      )
+    }
+
+    const exists = await fs.promises.exists(filePath)
+    if (!exists) {
+      throw new Error(`File doesn't exist at ${filePath}`)
+    }
+
+    childUploads.push({
+      propertyName: childProperty.propertyName,
+      localStoragePath: filePath,
+    })
+  }
+
+  // const filePath = itemProperty.localStoragePath
+  //
+  // if (!filePath) {
+  //   throw new Error(
+  //     `No localStoragePath found for ItemProperty ${itemProperty.propertyName}`,
+  //   )
+  // }
+  //
+  // const exists = await fs.promises.exists(filePath)
+  // if (!exists) {
+  //   throw new Error(`File doesn't exist at ${filePath}`)
+  //
+  //   // const handle = await navigator.storage.getDirectory()
+  //   //
+  //   // await configureSingle({
+  //   //   backend: WebAccess,
+  //   //   handle,
+  //   // })
+  // }
+  //
+  // const mainFileContents = await fs.promises.readFile(filePath)
+  let fileContents
+  let transaction: Transaction
+
+  if (!childUploads || childUploads.length === 0) {
+    if (relatedItemProperty && relatedItemProperty.localStoragePath) {
+      const filePath = relatedItemProperty.localStoragePath
+
+      const exists = await fs.promises.exists(filePath)
+      if (!exists) {
+        throw new Error(`File doesn't exist at ${filePath}`)
+
+        // const handle = await navigator.storage.getDirectory()
+        //
+        // await configureSingle({
+        //   backend: WebAccess,
+        //   handle,
+        // })
+      }
+
+      fileContents = await fs.promises.readFile(filePath)
+    }
+    if (!fileContents) {
+      return uploads
+    }
+  }
+
+  if (childUploads.length > 0) {
+    const separator = '===FILE_SEPARATOR==='
+    // let compositeFileContents = `${itemProperty.propertyName}${separator}${mainFileContents}`
+    let compositeFileContents = ''
+
+    for (const childUpload of childUploads) {
+      const childUploadContents = await fs.promises.readFile(
+        childUpload.localStoragePath,
+      )
+      compositeFileContents += `${separator}${childUpload.propertyName}${separator}${childUploadContents}`
+    }
+
+    fileContents = Buffer.from(compositeFileContents)
+  }
+
+  if (!fileContents) {
+    throw new Error(`No file contents found for ${itemProperty.propertyName}`)
+  }
+
+  const uint8Array = new Uint8Array(
+    fileContents.buffer,
+    fileContents.byteOffset,
+    fileContents.byteLength,
+  )
+
+  const contentHash = await getContentHash(null, uint8Array)
+
+  transaction = await prepareArweaveTransaction(fileContents, contentHash)
+
+  let itemPropertyLocalId = relatedItemProperty
+    ? relatedItemProperty.localId
+    : itemProperty.localId
+  let itemPropertyName = relatedItemProperty
+    ? relatedItemProperty.propertyName
+    : itemProperty.propertyName
+
+  uploads.push({
+    itemPropertyName,
+    itemPropertyLocalId,
+    seedLocalId: itemProperty.seedLocalId!,
+    versionLocalId: itemProperty.versionLocalId!,
+    transactionToSign: transaction,
+  })
+
+  return uploads
+}
+export type PublishUpload = {
+  itemPropertyName: string
+  itemPropertyLocalId: string
+  seedLocalId: string
+  versionLocalId: string
+  transactionToSign: Transaction
+}
+export const getPublishUploads = async (
+  item: Item<any>,
+  uploads: PublishUpload[] = [],
+  relatedItemProperty?: ItemProperty<any>,
+) => {
+  if (item.modelName === 'Post') {
+    if (!item.authors) {
+      item.authors = [
+        'Sr0bIx9Fwj',
+        '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+      ]
+    }
+  }
+
+  const { itemUploadProperties, itemRelationProperties } =
+    getSegmentedItemProperties(item)
+
+  for (const uploadProperty of itemUploadProperties) {
+    uploads = await processUploadProperty(
+      uploadProperty,
+      uploads,
+      relatedItemProperty,
+    )
+  }
+
+  for (const relationProperty of itemRelationProperties) {
+    const propertyValue = relationProperty.getService().getSnapshot()
+      .context.propertyValue
+
+    if (!propertyValue || relationProperty.uid) {
+      continue
+    }
+
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(propertyValue)
+
+    const relatedItem = await Item.find({
+      seedLocalId,
+      seedUid,
+    })
+
+    if (!relatedItem) {
+      throw new Error(
+        `No relatedItem found for ${relationProperty.propertyName}`,
+      )
+    }
+
+    uploads = await getPublishUploads(relatedItem, uploads, relationProperty)
+  }
+
+  return uploads
+}

package/dist/src/getSegmentedItemProperties.ts

@@ -0,0 +1,65 @@
+import { Item } from '@/browser'
+import { UploadProperty } from '@/browser/db/read/getPublishUploads'
+
+export const getSegmentedItemProperties = (item: Item<any>) => {
+  const itemBasicProperties = []
+  const itemRelationProperties = []
+  const itemListProperties = []
+  const itemUploadProperties: UploadProperty[] = []
+  const itemStorageProperties = []
+  let itemStorageTransactionProperty: UploadProperty | undefined
+
+  for (const itemProperty of Object.values(item.properties)) {
+    if (!itemProperty.propertyDef) {
+      continue
+    }
+
+    const isItemStorage =
+      itemProperty.propertyDef.storageType &&
+      itemProperty.propertyDef.storageType === 'ItemStorage'
+
+    const isImageSrc =
+      itemProperty.propertyDef.dataType === 'Relation' &&
+      itemProperty.propertyDef.refValueType === 'ImageSrc'
+
+    const isStorageTransaction =
+      itemProperty.propertyName === 'storageTransactionId'
+
+    if (itemProperty.propertyDef.dataType === 'Relation') {
+      itemRelationProperties.push(itemProperty)
+      continue
+    }
+
+    if (itemProperty.propertyDef.dataType === 'List') {
+      itemListProperties.push(itemProperty)
+      continue
+    }
+
+    if (isItemStorage) {
+      itemStorageProperties.push(itemProperty)
+      continue
+    }
+
+    if (isStorageTransaction) {
+      itemStorageTransactionProperty = { itemProperty, childProperties: [] }
+      continue
+    }
+
+    itemBasicProperties.push(itemProperty)
+  }
+
+  if (itemStorageTransactionProperty && itemStorageProperties.length > 0) {
+    itemStorageTransactionProperty.childProperties = itemStorageProperties
+  }
+
+  if (itemStorageTransactionProperty) {
+    itemUploadProperties.push(itemStorageTransactionProperty)
+  }
+
+  return {
+    itemBasicProperties,
+    itemRelationProperties,
+    itemListProperties,
+    itemUploadProperties,
+  }
+}

package/dist/src/hydrateFromDb.ts

@@ -21,7 +21,7 @@ export const hydrateFromDb = fromCallback<
     propertyName: propertyNameRaw,
     propertyValue,
     propertyRecordSchema,
-    itemModelName,
+    modelName,
   } = context
 
   let propertyName = propertyNameRaw
@@ -264,8 +264,8 @@ export const hydrateFromDb = fromCallback<
       schemaUid: schemaUidFromDb,
       refValueType,
       localStorageDir,
-      resolvedValue: refResolvedValue,
-      resolvedDisplayValue: refResolvedDisplayValue,
+      refResolvedValue,
+      refResolvedDisplayValue,
       renderValue: refResolvedDisplayValue,
       populatedFromDb: true,
     })
@@ -278,7 +278,7 @@ export const hydrateFromDb = fromCallback<
       const { Item } = await import(`@/browser/item`)
       const item = await Item.find({
         seedLocalId,
-        modelName: itemModelName,
+        modelName,
       })
       if (item) {
         const filePath = `/files/${localStorageDir}/${refResolvedValue}`

package/dist/src/index.ts

@@ -1,21 +1,73 @@
-import { setup } from 'xstate'
+import { assign, setup } from 'xstate'
 import {
-  uploadBinaryData,
-  uploadMetadata,
-} from '@/browser/schema/file/upload/actors'
+  fetchAllBinaryData,
+  fetchAllMetadataRecords,
+} from '@/browser/schema/file/fetchAll/actors'
+import { Attestation } from '@/browser/gql/graphql'
 
-export const uploadMachine = setup({
+type FetchAllFilesMachineContext = {
+  addresses: string[]
+  dbsLoaded: boolean
+  filesMetadata?: Attestation[]
+  filesBlobData?: any[]
+}
+
+export const fetchAllFilesMachine = setup({
+  types: {
+    context: {} as FetchAllFilesMachineContext,
+  },
   actors: {
-    uploadBinaryData,
-    uploadMetadata,
+    fetchAllMetadataRecords,
+    fetchAllBinaryData,
   },
 }).createMachine({
-  id: 'upload',
+  id: 'fetchAllFiles',
   initial: 'idle',
-  context: {
-    file: '',
+  context: ({ input }) =>
+    ({
+      ...input,
+      dbsLoaded: false,
+    }) as FetchAllFilesMachineContext,
+  on: {
+    allDbsLoaded: {
+      target: '.fetchingAllMetadataRecords',
+      actions: assign({
+        dbsLoaded: true,
+      }),
+    },
   },
   states: {
     idle: {},
+    fetchingAllMetadataRecords: {
+      on: {
+        fetchingAllMetadataRecordsSuccess: {
+          target: 'fetchingAllBinaryData',
+          actions: assign({
+            filesMetadata: ({ event }) => event.filesMetadata,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchAllMetadataRecords',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    fetchingAllBinaryData: {
+      on: {
+        fetchingAllBinaryDataSuccess: {
+          target: 'success',
+          actions: assign({
+            filesBlobData: ({ event }) => event.filesBlobData,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchAllBinaryData',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    success: {
+      type: 'final',
+    },
   },
 })

package/dist/src/propertyMachine.ts

@@ -105,8 +105,9 @@ export const propertyMachine = setup({
         resolvingRelatedValueSuccess: {
           target: 'idle',
           actions: assign({
-            resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
-            resolvedValue: ({ event }) => event.resolvedValue,
+            refResolvedDisplayValue: ({ event }) =>
+              event.refResolvedDisplayValue,
+            resolvedValue: ({ event }) => event.refResolvedValue,
           }),
         },
         resolvingRelatedValueDone: {

package/dist/src/read.ts

@@ -43,7 +43,7 @@ export const getPropertyData = async (
 
   return {
     ...row,
-    itemModelName: startCase(row.modelType),
+    modelName: startCase(row.modelType),
   }
 }
 

package/dist/src/resolveRelatedValue.ts

@@ -50,7 +50,7 @@ export const resolveRelatedValue = fromCallback<
       })
       sendBack({
         type: 'resolvingRelatedValueSuccess',
-        resolvedDisplayValue: contentUrl,
+        refResolvedDisplayValue: contentUrl,
       })
       return true
     }
@@ -79,8 +79,8 @@ export const resolveRelatedValue = fromCallback<
         })
         sendBack({
           type: 'resolvingRelatedValueSuccess',
-          resolvedDisplayValue: contentUrl,
-          resolvedValue: storageTransactionId,
+          refResolvedDisplayValue: contentUrl,
+          refResolvedValue: storageTransactionId,
         })
         return true
       }
@@ -95,8 +95,8 @@ export const resolveRelatedValue = fromCallback<
       })
       sendBack({
         type: 'resolvingRelatedValueSuccess',
-        resolvedDisplayValue: contentUrl,
-        resolvedValue: storageTransactionId,
+        refResolvedDisplayValue: contentUrl,
+        refResolvedValue: storageTransactionId,
       })
       return true
     }
@@ -122,7 +122,7 @@ export const resolveRelatedValue = fromCallback<
           })
           sendBack({
             type: 'resolvingRelatedValueSuccess',
-            resolvedDisplayValue: contentUrl,
+            refResolvedDisplayValue: contentUrl,
           })
           return true
         }
@@ -143,7 +143,7 @@ export const resolveRelatedValue = fromCallback<
           })
           sendBack({
             type: 'resolvingRelatedValueSuccess',
-            resolvedDisplayValue: contentUrl,
+            refResolvedDisplayValue: contentUrl,
           })
           return true
         }
@@ -186,7 +186,7 @@ export const resolveRelatedValue = fromCallback<
             })
             sendBack({
               type: 'resolvingRelatedValueSuccess',
-              resolvedDisplayValue: contentUrl,
+              refResolvedDisplayValue: contentUrl,
             })
             return true
           }
@@ -282,13 +282,13 @@ export const resolveRelatedValue = fromCallback<
 //         )
 //       }
 //
-//       const resolvedDisplayValue = storageIdQuery.rows[0][2]
+//       const refResolvedDisplayValue = storageIdQuery.rows[0][2]
 //       let resolvedValue = storageIdQuery.rows[0][3]
 //
-//       if (resolvedDisplayValue && resolvedValue) {
+//       if (refResolvedDisplayValue && resolvedValue) {
 //         sendBack({
 //           type: 'resolvingRelatedValueSuccess',
-//           resolvedDisplayValue,
+//           refResolvedDisplayValue,
 //           resolvedValue,
 //         })
 //         return
@@ -320,7 +320,7 @@ export const resolveRelatedValue = fromCallback<
 //
 //       sendBack({
 //         type: 'resolvingRelatedValueSuccess',
-//         resolvedDisplayValue: contentUrl,
+//         refResolvedDisplayValue: contentUrl,
 //         resolvedValue: storageId,
 //       })
 //     }

package/dist/src/saveImageSrc.ts

@@ -74,7 +74,7 @@ export const saveImageSrc = fromCallback<
     propertyName: propertyNameRaw,
     propertyValue: existingValue,
     propertyRecordSchema,
-    itemModelName,
+    modelName,
     seedLocalId,
     seedUid,
     versionLocalId,
@@ -182,7 +182,7 @@ export const saveImageSrc = fromCallback<
           seedUid,
           versionLocalId,
           versionUid,
-          modelName: itemModelName,
+          modelName,
           schemaUid,
           refSeedType: 'image',
           refModelUid: imageSchemaUid,
@@ -203,7 +203,7 @@ export const saveImageSrc = fromCallback<
         newValue: newImageSeedLocalId,
         seedLocalId,
         versionLocalId,
-        modelName: itemModelName,
+        modelName,
         schemaUid,
         refSeedType: 'image',
         refResolvedDisplayValue,
@@ -221,8 +221,8 @@ export const saveImageSrc = fromCallback<
       refSeedType: 'image',
       refSchemaUid: imageSchemaUid,
       renderValue: refResolvedDisplayValue,
-      resolvedDisplayValue: refResolvedDisplayValue,
-      resolvedValue: fileName,
+      refResolvedDisplayValue: refResolvedDisplayValue,
+      refResolvedValue: fileName,
       localStorageDir: '/images',
       easDataType: 'bytes32',
     })

package/dist/src/saveItemStorage.ts

@@ -23,7 +23,7 @@ export const saveItemStorage = fromCallback<
     seedUid,
     propertyName,
     propertyRecordSchema,
-    itemModelName,
+    modelName,
     propertyValue: existingValue,
   } = context
 
@@ -82,7 +82,7 @@ export const saveItemStorage = fromCallback<
           const propertyDataRows = await createMetadata(
             {
               propertyName,
-              modelType: itemModelName.toLowerCase(),
+              modelType: modelName.toLowerCase(),
               seedLocalId,
               seedUid,
               versionLocalId: itemData.latestVersionLocalId,

package/dist/src/seed.ts

@@ -1,10 +1,37 @@
-import { SeedConstructorOptions } from '@/types/types'
-import { SeedBase } from '@/shared/seed'
+import { isBrowser, isNode, isReactNative } from '@/shared/environment'
+import { Endpoints, SeedConstructorOptions } from '@/types/types'
+import { Subject } from 'rxjs'
 
-class SeedNode extends SeedBase {
+type Environment = 'node' | 'browser' | 'react-native'
+
+abstract class SeedBase {
+  private readonly _env: Environment = 'browser'
+  protected _subject: Subject<void> = new Subject<void>()
+
+  constructor(props: { endpoints: Endpoints }) {
+    console.log('Seed constructor called')
+    if (isNode()) {
+      this._env = 'node'
+    }
+    if (isBrowser()) {
+      this._env = 'browser'
+    }
+    if (isReactNative()) {
+      this._env = 'react-native'
+    }
+  }
+
+  async initialize() {}
+
+  subscribe(callback: (event: any) => void) {
+    return this._subject.subscribe(callback)
+  }
+}
+
+class SeedSync extends SeedBase {
   constructor(props: SeedConstructorOptions) {
     super(props)
   }
 }
 
-export { SeedNode }
+export { SeedBase, SeedSync }

package/dist/types/src/browser/db/read/getPublishPayload.d.ts

@@ -1,4 +1,5 @@
 import { AttestationRequest } from '@ethereum-attestation-service/eas-sdk';
+import { Item } from '@/browser/item/Item';
 type PublishPayload = {
     localId: string;
     seedIsRevocable: boolean;
@@ -10,6 +11,13 @@ type PublishPayload = {
     propertiesToUpdate: any[];
 };
 type MultiPublishPayload = PublishPayload[];
-export declare const getPublishPayload: (seedLocalId: string) => Promise<MultiPublishPayload>;
+type UploadedTransaction = {
+    txId: string;
+    itemPropertyLocalId?: string;
+    seedLocalId?: string;
+    versionLocalId?: string;
+    itemPropertyName?: string;
+};
+export declare const getPublishPayload: (item: Item<any>, uploadedTransactions: UploadedTransaction[]) => Promise<MultiPublishPayload>;
 export {};
 //# sourceMappingURL=getPublishPayload.d.ts.map

package/dist/types/src/browser/db/read/getPublishPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPublishPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getPublishPayload.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,kBAAkB,EAGnB,MAAM,uCAAuC,CAAA;AAwQ9C,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,OAAO,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;IACxC,kBAAkB,EAAE,GAAG,EAAE,CAAA;CAC1B,CAAA;AAED,KAAK,mBAAmB,GAAG,cAAc,EAAE,CAAA;AAE3C,eAAO,MAAM,iBAAiB,gBACf,MAAM,KAClB,OAAO,CAAC,mBAAmB,CA8D7B,CAAA"}
+{"version":3,"file":"getPublishPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getPublishPayload.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,kBAAkB,EAGnB,MAAM,uCAAuC,CAAA;AAS9C,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AA0O1C,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,OAAO,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;IACxC,kBAAkB,EAAE,GAAG,EAAE,CAAA;CAC1B,CAAA;AAED,KAAK,mBAAmB,GAAG,cAAc,EAAE,CAAA;AAE3C,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,IAAI,CAAC,GAAG,CAAC,wBACO,mBAAmB,EAAE,KAC1C,OAAO,CAAC,mBAAmB,CAsE7B,CAAA"}

package/dist/types/src/browser/db/read/getPublishUploads.d.ts

@@ -0,0 +1,17 @@
+import { Item, ItemProperty } from '@/browser';
+import Transaction from 'arweave/web/lib/transaction';
+export declare const getContentHash: (base64: string | null | undefined, uint: Uint8Array | undefined) => Promise<string>;
+export declare const prepareArweaveTransaction: (data: string | Uint8Array, contentHash: string | undefined) => Promise<Transaction>;
+export type UploadProperty = {
+    itemProperty: ItemProperty<any>;
+    childProperties: ItemProperty<any>[];
+};
+export type PublishUpload = {
+    itemPropertyName: string;
+    itemPropertyLocalId: string;
+    seedLocalId: string;
+    versionLocalId: string;
+    transactionToSign: Transaction;
+};
+export declare const getPublishUploads: (item: Item<any>, uploads?: PublishUpload[], relatedItemProperty?: ItemProperty<any>) => Promise<PublishUpload[]>;
+//# sourceMappingURL=getPublishUploads.d.ts.map

package/dist/types/src/browser/db/read/getPublishUploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPublishUploads.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getPublishUploads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,WAAW,MAAM,6BAA6B,CAAA;AAUrD,eAAO,MAAM,cAAc,WACjB,MAAM,GAAG,IAAI,GAAG,SAAS,QAC3B,UAAU,GAAG,SAAS,KAC3B,OAAO,CAAC,MAAM,CAkBhB,CAAA;AACD,eAAO,MAAM,yBAAyB,SAC9B,MAAM,GAAG,UAAU,eACZ,MAAM,GAAG,SAAS,KAC9B,OAAO,CAAC,WAAW,CAerB,CAAA;AACD,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,YAAY,CAAC,GAAG,CAAC,CAAA;IAC/B,eAAe,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAA;CACrC,CAAA;AA+HD,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,WAAW,CAAA;CAC/B,CAAA;AACD,eAAO,MAAM,iBAAiB,SACtB,IAAI,CAAC,GAAG,CAAC,YACN,aAAa,EAAE,wBACF,YAAY,CAAC,GAAG,CAAC,6BA+CxC,CAAA"}

package/dist/types/src/browser/helpers/arweave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arweave.d.ts","sourceRoot":"","sources":["../../../../../src/browser/helpers/arweave.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B,eAAO,MAAM,UAAU,QAAO,OAAO,GAAG,SAyCvC,CAAA"}

package/dist/types/src/browser/helpers/getSegmentedItemProperties.d.ts

@@ -0,0 +1,9 @@
+import { Item } from '@/browser';
+import { UploadProperty } from '@/browser/db/read/getPublishUploads';
+export declare const getSegmentedItemProperties: (item: Item<any>) => {
+    itemBasicProperties: import("@/browser").ItemProperty<any>[];
+    itemRelationProperties: import("@/browser").ItemProperty<any>[];
+    itemListProperties: import("@/browser").ItemProperty<any>[];
+    itemUploadProperties: UploadProperty[];
+};
+//# sourceMappingURL=getSegmentedItemProperties.d.ts.map