@seedprotocol/sdk 0.2.43 → 0.2.45

package/dist/{index-BWIn7kWN.js → index-Km3L1_LR.js}

@@ -1,28 +1,25 @@
-export { I as Item } from './index-DcPIAiHD.js';
+export { I as Item } from './index-CsbUKGXp.js';
 import 'immer';
 import 'reflect-metadata';
-import 'tslib';
 import '@sinclair/typebox';
-import 'eventemitter3';
+import 'xstate';
+import './constants-Dgv-tSO3.js';
+import '@ethereum-attestation-service/eas-sdk';
+import 'pluralize';
+import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
-import 'react';
+import 'eventemitter3';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@zenfs/core';
 import 'debug';
-import 'drizzle-orm/sqlite-core';
-import './constants-BakHTrB9.js';
-import '@ethereum-attestation-service/eas-sdk';
-import 'xstate';
-import 'pluralize';
 import 'lodash-es';
 import '@statelyai/inspect';
 import 'node:fs';
-import '@zenfs/dom';
 import 'path';
 import 'arweave';
-import 'threads';
 import 'rxjs';
+import 'react';
 import 'use-immer';
 import '@xstate/react';
-//# sourceMappingURL=index-BWIn7kWN.js.map
+//# sourceMappingURL=index-Km3L1_LR.js.map

package/dist/index-Km3L1_LR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Km3L1_LR.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/main.js

@@ -1,28 +1,25 @@
 import 'immer';
 import 'reflect-metadata';
-export { D as Db, c as ImageSrc, d as Item, e as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, t as client, r as eventEmitter, p as getCorrectId, q as getGlobalService, h as useCreateItem, j as useDeleteItem, k as useGlobalServiceStatus, f as useItem, g as useItemProperties, i as useItemProperty, u as useItems, m as usePersistedSnapshots, l as usePublishItem, o as useService, n as useServices, s as withSeed } from './index-DcPIAiHD.js';
-export { B as BaseArweaveClient, a as BaseEasClient, c as BaseFileManager, b as BaseQueryClient } from './constants-BakHTrB9.js';
-import 'tslib';
+export { D as Db, c as ImageSrc, d as Item, e as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, v as client, r as eventEmitter, p as getCorrectId, q as getGlobalService, h as useCreateItem, j as useDeleteItem, k as useGlobalServiceStatus, f as useItem, g as useItemProperties, i as useItemProperty, u as useItems, m as usePersistedSnapshots, l as usePublishItem, o as useService, n as useServices, t as withSeed } from './index-CsbUKGXp.js';
+export { B as BaseArweaveClient, a as BaseEasClient, c as BaseFileManager, b as BaseQueryClient } from './constants-Dgv-tSO3.js';
 import '@sinclair/typebox';
-import 'eventemitter3';
+import 'xstate';
+import 'pluralize';
+import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
-import 'react';
+import 'eventemitter3';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@zenfs/core';
 import 'debug';
-import 'drizzle-orm/sqlite-core';
-import 'xstate';
-import 'pluralize';
 import 'lodash-es';
 import '@statelyai/inspect';
 import 'node:fs';
-import '@zenfs/dom';
 import 'path';
 import 'arweave';
-import 'threads';
 import 'rxjs';
 import '@ethereum-attestation-service/eas-sdk';
+import 'react';
 import 'use-immer';
 import '@xstate/react';
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node/codegen/templates/index.njk

@@ -8,8 +8,6 @@ import { versions } from '../../seed/schema/VersionSchema'
 import { metadata } from '../../seed/schema/MetadataSchema'
 import { models } from '../../seed/schema/ModelSchema'
 import { modelUids } from '../../seed/schema/ModelUidSchema'
-import { propertyUids } from '../../seed/schema/PropertyUidSchema'
-import { config } from '../../seed/schema/Config'
 {% for model in models %}
 export * from './{{ model.name }}Schema'
 {%- endfor %}
@@ -23,8 +21,6 @@ tablesByName.set('versions', versions)
 tablesByName.set('metadata', metadata)
 tablesByName.set('models', models)
 tablesByName.set('modelUids', modelUids)
-tablesByName.set('propertyUids', propertyUids)
-tablesByName.set('config', config)
 
 export const getTable = (table: string) => {
   return tablesByName.get(table)

package/dist/{seed.schema.config-DGcg6TCS.js → seed.schema.config-Dn_1QbD7.js}

@@ -1,28 +1,26 @@
 import { __decorate, __metadata } from 'tslib';
 import 'reflect-metadata';
-import { T as Text, M as Model } from './index-DcPIAiHD.js';
+import { T as Text, M as Model } from './index-CsbUKGXp.js';
 import 'immer';
 import '@sinclair/typebox';
-import 'eventemitter3';
+import 'xstate';
+import './constants-Dgv-tSO3.js';
+import '@ethereum-attestation-service/eas-sdk';
+import 'pluralize';
+import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
-import 'react';
+import 'eventemitter3';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@zenfs/core';
 import 'debug';
-import 'drizzle-orm/sqlite-core';
-import './constants-BakHTrB9.js';
-import '@ethereum-attestation-service/eas-sdk';
-import 'xstate';
-import 'pluralize';
 import 'lodash-es';
 import '@statelyai/inspect';
 import 'node:fs';
-import '@zenfs/dom';
 import 'path';
 import 'arweave';
-import 'threads';
 import 'rxjs';
+import 'react';
 import 'use-immer';
 import '@xstate/react';
 
@@ -72,4 +70,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-DGcg6TCS.js.map
+//# sourceMappingURL=seed.schema.config-Dn_1QbD7.js.map

package/dist/seed.schema.config-Dn_1QbD7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.schema.config-Dn_1QbD7.js","sources":["../../src/db/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/schema'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/seedSchema/index.ts

@@ -2,7 +2,5 @@ export * from './SeedSchema'
 export * from './VersionSchema'
 export * from './MetadataSchema'
 export * from './AppStateSchema'
-export * from './ConfigSchema'
 export * from './ModelSchema'
 export * from './ModelUidSchema'
-export * from './PropertyUidSchema'

package/dist/src/BaseFileManager.ts

@@ -1,11 +1,40 @@
 export abstract class BaseFileManager {
+  private fileSystemInitialized = false
+  private initializing = false
+
   static PlatformClass: typeof BaseFileManager
 
-  static setPlatformClass(platformClass: typeof BaseFileManager) {
+  static setPlatformClass( platformClass: typeof BaseFileManager ) {
     this.PlatformClass = platformClass
   }
 
-  static getContentUrlFromPath(path: string): Promise<string | undefined> {
+  static async initializeFileSystem(): Promise<void> {
+    if (this.initializing || this.fileSystemInitialized) {
+      return Promise.resolve()
+    }
+    this.initializing = true
+    await this.PlatformClass.initializeFileSystem()
+    this.fileSystemInitialized = true
+    this.initializing = false
+  }
+
+  static getContentUrlFromPath( path: string ): Promise<string | undefined> {
     return this.PlatformClass.getContentUrlFromPath(path)
   }
+
+  static downloadAllFiles( {
+                             transactionIds,
+                             arweaveHost,
+                             excludedTransactions,
+                           }: DownloadAllFilesParams ): Promise<void> {
+    return this.PlatformClass.downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions })
+  }
+
+  static resizeImage( { filePath, width, height }: ResizeImageParams ): Promise<void> {
+    return this.PlatformClass.resizeImage({ filePath, width, height })
+  }
+
+  static resizeAllImages( { width, height }: ResizeAllImagesParams ): Promise<void> {
+    return this.PlatformClass.resizeAllImages({ width, height })
+  }
 }

package/dist/src/BaseItem.ts

@@ -32,7 +32,7 @@ import { createNewItem } from '@/db/write/createNewItem'
 
 export abstract class BaseItem<T extends ModelValues<ModelSchema>> implements IItem<T> {
 
-  protected static instanceCache: Map<string, { instance: IItem<any>; refCount: number }> = new Map();
+  protected static instanceCache: Map<string, { instance: BaseItem<any>; refCount: number }> = new Map();
   protected _subscription: Subscription | undefined;
   protected readonly _storageTransactionId: string | undefined;
   [immerable] = true;
@@ -185,7 +185,7 @@ export abstract class BaseItem<T extends ModelValues<ModelSchema>> implements II
 
   static async create<T extends ModelValues<ModelSchema>>(
     props: Partial<ItemData>,
-  ): Promise<IItem<any>> {
+  ): Promise<BaseItem<any>> {
     if (!props.modelName && props.type) {
       props.modelName = startCase(props.type)
     }
@@ -226,10 +226,11 @@ export abstract class BaseItem<T extends ModelValues<ModelSchema>> implements II
     if (!props.modelName) {
       throw new Error('Model name is required to create an item')
     }
-    const { seedLocalId } = await createNewItem({
+    const { seedLocalId, versionLocalId, versionUid } = await createNewItem({
       modelName: props.modelName,
     })
     props.seedLocalId = seedLocalId
+    props.latestVersionLocalId = versionLocalId
     const newInstance = new this(props)
     this.instanceCache.set(newInstance.seedUid || newInstance.seedLocalId, {
       instance: newInstance,

package/dist/src/BaseItemProperty.ts

@@ -30,7 +30,7 @@ type ItemPropertyFindProps = {
 export abstract class BaseItemProperty<PropertyType> implements IItemProperty<PropertyType> {
   protected static instanceCache: Map<
     string,
-    { instance: IItemProperty<any>; refCount: number }
+    { instance: BaseItemProperty<any>; refCount: number }
   > = new Map()
   protected readonly _service: ItemPropertyService
   protected _subject: BehaviorSubject<any>
@@ -221,7 +221,7 @@ export abstract class BaseItemProperty<PropertyType> implements IItemProperty<Pr
 
   static create(
     props: Partial<CreatePropertyInstanceProps>,
-  ): IItemProperty<any> | undefined {
+  ): BaseItemProperty<any> | undefined {
     const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } =
       props
     if (!propertyName || (!seedLocalId && !seedUid)) {

package/dist/src/FileDownloader.ts

@@ -0,0 +1,63 @@
+import { saveAppState } from '@/db/write/saveAppState.js';
+import filesDownload from './filesDownload.js'
+
+
+
+export class FileDownloader {
+  private cores: number
+  private workersArchive: Worker[] = []
+  private workerBlobUrl: string
+
+  constructor() {
+    this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+
+    this.workerBlobUrl = globalThis.URL.createObjectURL(
+      new Blob([filesDownload], { type: 'application/javascript' })
+    )
+  }
+
+  public downloadAll = async ({transactionIds, arweaveHost, excludedTransactions}: DownloadAllFilesParams): Promise<void> => {
+
+    if (this.workersArchive.length > 0) {
+      for (let i = 0; i < this.workersArchive.length; i++) {
+        this.workersArchive[i].terminate()
+        delete this.workersArchive[i]
+      }
+      this.workersArchive = []
+    }
+
+    const worker = new Worker(this.workerBlobUrl);
+
+    this.workersArchive.push(worker)
+
+    const localExcludedTransactions = new Set(excludedTransactions)
+
+    return new Promise((resolve, reject) => {
+      worker.onmessage = (e) => {
+        console.log('filesDownload main thread onmessage', e.data);
+
+        if (e.data.message === 'excludeTransaction') {
+          localExcludedTransactions.add(e.data.transactionId)
+        }
+
+        if (e.data.done) {
+          saveAppState('excludedTransactions', JSON.stringify(Array.from(localExcludedTransactions)))
+          .then(() => {
+            resolve(e.data)
+          })
+          .catch((error) => {
+            reject(error)
+          })
+        }
+        if (e.data.error) {
+          reject(e.data.error)
+        }
+      }
+  
+      worker.postMessage({
+        transactionIds,
+        arweaveHost,
+      });
+    })
+  }
+}

package/dist/src/FileManager.ts

@@ -1,13 +1,44 @@
-import * as fsAsync from 'fs/promises';
-import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager';
+import * as fsAsync        from 'fs/promises'
+import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'
 
 class FileManager extends BaseFileManager {
-  static async readFileAsBuffer(filePath: string): Promise<Buffer> {
-    return await fsAsync.readFile(filePath);
+
+  static async readFileAsBuffer( filePath: string ): Promise<Buffer> {
+    return await fsAsync.readFile(filePath)
+  }
+
+  static async getContentUrlFromPath( path: string ): Promise<string | undefined> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async initializeFileSystem(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async downloadAllFiles(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async resizeImage(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async resizeAllImages(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
   }
 
 }
 
-BaseFileManager.setPlatformClass(FileManager);
+BaseFileManager.setPlatformClass(FileManager)
 
-export { FileManager }; 
+export { FileManager }

package/dist/src/ImageResizer.ts

@@ -0,0 +1,84 @@
+import fs from '@zenfs/core';
+import imageResize from './imageResize'
+
+
+
+export class ImageResizer {
+  private cores: number
+  private workersArchive: Map<string, Worker> = new Map()
+  private workerBlobUrl: string
+
+  constructor() {
+    this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+
+    this.workerBlobUrl = globalThis.URL.createObjectURL(
+      new Blob([imageResize], { type: 'application/javascript' })
+    )
+  }
+
+    public async resize({filePath, width, height}: ResizeImageParams) {
+      
+    if (this.workersArchive.has(filePath)) {
+      const savedWorker = this.workersArchive.get(filePath)
+      savedWorker?.terminate()
+      console.log('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath)
+      this.workersArchive.delete(filePath)
+    }
+
+    const worker = new Worker(this.workerBlobUrl);
+
+    this.workersArchive.set(filePath, worker)
+
+    return new Promise((resolve, reject) => {
+      worker.onmessage = (e) => {
+        console.log('[ImageResizer.resize] main thread onmessage', e.data);
+        if (e.data.done) {
+          const savedWorker = this.workersArchive.get(filePath)
+          savedWorker?.terminate()
+          console.log('[ImageResizer.resize] Terminated worker for filePath due to done', filePath)
+          this.workersArchive.delete(filePath)
+          resolve(e.data)
+        }
+
+        if (e.data.error) {
+          reject(e.data.error)
+        }
+      }
+  
+      worker.postMessage({
+        filePath,
+        width,
+        height,
+      });
+    })
+  }
+
+  public async resizeAll({width, height}: ResizeAllImagesParams) {
+
+    const imageDir = '/files/images'
+    let imageFilesStats = await fs.promises.readdir(imageDir, {
+      withFileTypes: true
+    })
+
+    imageFilesStats = imageFilesStats.filter(file => file.isFile())
+
+    const imageFiles = imageFilesStats.map(file => file.path)
+
+    const widthDir = `${imageDir}/${width}`
+
+    const widthDirExists = await fs.promises.exists(widthDir)
+
+    if (!widthDirExists) {
+      await fs.promises.mkdir(widthDir)
+    }
+
+    for (const imageFile of imageFiles) {
+      const resizedImageExists = await fs.promises.exists(`${widthDir}/${imageFile}`)
+      if (!resizedImageExists) {
+        await this.resize({filePath: `${imageDir}/${imageFile}`, width, height})
+      }
+    }
+
+  
+  }
+}

package/dist/src/analyzeInput.ts

@@ -97,7 +97,7 @@ export const analyzeInput = fromCallback<
       }
     }
 
-    await updateItemPropertyValue({
+    const result = await updateItemPropertyValue({
       localId,
       propertyName,
       newValue,
@@ -108,9 +108,29 @@ export const analyzeInput = fromCallback<
       schemaUid,
     })
 
+    let updatedContext: Partial<PropertyMachineContext> = {
+      propertyValue: newValue,
+    }
+
+    if (localId) {
+      updatedContext.localId = localId
+    }
+
+    if (schemaUid) {
+      updatedContext.schemaUid = schemaUid
+    }
+
+    if (!localId && result?.localId) {
+      updatedContext.localId = result.localId
+    }
+
+    if (!schemaUid && result?.schemaUid) {
+      updatedContext.schemaUid = result.schemaUid
+    }
+
     sendBack({
       type: 'updateContext',
-      propertyValue: newValue,
+      ...updatedContext,
     })
 
     return true

package/dist/src/configureFs.ts

@@ -20,7 +20,7 @@ export const configureFs = fromCallback<
 
   logger('[internal/actors] [configureFs] Configuring FS')
 
-  const _configureFs = async (): Promise<void> => {
+  const _configureFs = async (): Promise<boolean> => {
     logger('[internal/actors] [configureFs] calling _configureFs')
 
     logger(
@@ -44,12 +44,24 @@ export const configureFs = fromCallback<
 
     const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`
 
-    const journalExists = await fs.promises.exists(journalPath)
+
+    let journalExists = await fs.promises.exists(journalPath)
+
+    if (!journalExists) {
+      journalExists = fs.existsSync(journalPath)
+    }
 
     if (journalExists) {
       appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+      logger('[internal/actors] [configureFs] fs configured!')
+      return true
     }
 
+    sendBack({ type: 'shouldWaitForFiles' })
+    
+
+    return false
+
     // return new Promise<void>((resolve) => {
     //   const interval = setInterval(() => {
     //     journalExistsSync = fs.existsSync(journalPath)
@@ -65,15 +77,16 @@ export const configureFs = fromCallback<
     //   }, 200)
     // })
 
-    logger('[internal/actors] [configureFs] fs configured!')
   }
 
   // Some of our dependencies use fs sync functions, which don't work with
   // OPFS. ZenFS creates an async cache of all files so that the sync functions
   // work, but we have to wait for it to be built. Otherwise things like
   // drizzleMigrate will fail since they can't see the migration files yet.
-  _configureFs().then(() => {
-    sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS })
+  _configureFs().then((fsConfigured) => {
+    if (fsConfigured) {
+      sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS })
+    }
     return
   })