@iebh/tera-fy 2.0.21 → 2.2.0

package/dist/utils/mixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.js","sourceRoot":"","sources":["../../utils/mixin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;EASE;AACF,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,QAAa,EAAE,WAAgB;IAC5D,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,CACzB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,EAC9C,QAAQ,EACR,WAAW,CACX,CAAC;IACF,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/utils/pDefer.d.ts

@@ -0,0 +1,12 @@
+/**
+* Returns a defer object which represents a promise object which can resolve in the future - but without enclosing a function
+* The defer object has the keys {promise, resolve(), reject()}
+* @returns {Defer} A defered promise
+*/
+interface Defer {
+    promise: Promise<unknown>;
+    resolve: (value?: unknown | PromiseLike<unknown>) => void;
+    reject: (reason?: any) => void;
+}
+export default function (): Defer;
+export {};

package/dist/utils/pDefer.js

@@ -0,0 +1,14 @@
+/**
+* Returns a defer object which represents a promise object which can resolve in the future - but without enclosing a function
+* The defer object has the keys {promise, resolve(), reject()}
+* @returns {Defer} A defered promise
+*/
+export default function () {
+    var deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}
+//# sourceMappingURL=pDefer.js.map

package/dist/utils/pDefer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pDefer.js","sourceRoot":"","sources":["../../utils/pDefer.ts"],"names":[],"mappings":"AAAA;;;;EAIE;AAQF,MAAM,CAAC,OAAO;IACb,IAAI,QAAQ,GAAG,EAAW,CAAC;IAE3B,QAAQ,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAClD,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC;QAC3B,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/utils/pathTools.d.ts

@@ -0,0 +1,70 @@
+/**
+* General path setters / getters for project state
+* These are _MAINLY_ wrappers for Lodash functionality such as Lodash.set() / Lodash.get(), any deviations are documented inline
+*
+* In each case these functions work with either dotted or array notation against a target master-object
+*     - Dotted notation - e.g. `foo.bar.1.baz`
+*     - Array path segments e.g. `['foo', 'bar', 1, 'baz']`
+*/
+/**
+* Internal recursive path setter
+*
+* Conflict strategies (copied from utils/pathTools @ `set()`)
+*     - 'set' / 'overwrite' - Just overwrite any existing value
+*     - 'merge' - Merge existing values using Lodash.merge()
+*     - 'defaults' - Merge existing values using Lodash.defaultsDeep()
+*
+* @param {Object} target The target to operate on
+* @param {String|Array} path The path within the target to set, in dotted or array notation
+* @param {*} value The value to set
+* @param {Object} [options] Additional options to mutate behaviour
+* @param {'set'|'overwrite'|'merge'|'defaults'} [options.strategy='set'] How to handle an existing value, if any
+*
+* @returns {*} The set value
+*/
+export declare function set(target: any, path: string | (string | number)[], value: any, options?: any): any;
+/**
+* Internal recursive path fetcher
+*
+* @param {Object} target The target to examine
+* @param {String|Array} path The path within the target to fetch, in dotted or array notation
+* @param {*} [fallback] Optional fallback to return if the end point does not exist
+* @returns {*} The fetched value
+*/
+export declare function get(target: any, path: string | (string | number)[], fallback?: any): any;
+/**
+* Internal recursive path checker
+*
+* @param {Object} target The target to examine
+* @param {String|Array} path The path within the target, to fetch in dotted or array notation
+* @returns {Boolean} True if the given path already exists within the subject
+*/
+export declare function has(target: any, path: string | (string | number)[]): boolean;
+/**
+* Internal recursive path merger
+*
+* @param {Object} target The target to operate on, this is likly to be mutated
+* @param {String|Array} path The path within the target to merge, in dotted or array notation
+* @param {*} value The value to merge
+*
+* @returns {*} The merged value
+*/
+export declare function merge(target: any, path: string | (string | number)[], value: any): any;
+/**
+* Internal recursive path defaulter
+*
+* @param {Object} target The target to operate on, this is likly to be mutated
+* @param {String|Array} [path] The path within the target to merge, in dotted or array notation
+* @param {*} value The value to merge
+*
+* @returns {*} The resulting object with defaults applied
+*/
+export declare function defaults(target: any, path: string | (string | number)[] | any, value?: any): any;
+declare const _default: {
+    set: typeof set;
+    get: typeof get;
+    has: typeof has;
+    merge: typeof merge;
+    defaults: typeof defaults;
+};
+export default _default;

package/dist/utils/pathTools.js

@@ -0,0 +1,120 @@
+import { defaultsDeep as _defaults, get as _get, has as _has, merge as _merge, set as _set, } from 'lodash-es';
+/**
+* General path setters / getters for project state
+* These are _MAINLY_ wrappers for Lodash functionality such as Lodash.set() / Lodash.get(), any deviations are documented inline
+*
+* In each case these functions work with either dotted or array notation against a target master-object
+*     - Dotted notation - e.g. `foo.bar.1.baz`
+*     - Array path segments e.g. `['foo', 'bar', 1, 'baz']`
+*/
+/**
+* Internal recursive path setter
+*
+* Conflict strategies (copied from utils/pathTools @ `set()`)
+*     - 'set' / 'overwrite' - Just overwrite any existing value
+*     - 'merge' - Merge existing values using Lodash.merge()
+*     - 'defaults' - Merge existing values using Lodash.defaultsDeep()
+*
+* @param {Object} target The target to operate on
+* @param {String|Array} path The path within the target to set, in dotted or array notation
+* @param {*} value The value to set
+* @param {Object} [options] Additional options to mutate behaviour
+* @param {'set'|'overwrite'|'merge'|'defaults'} [options.strategy='set'] How to handle an existing value, if any
+*
+* @returns {*} The set value
+*/
+export function set(target, path, value, options) {
+    let settings = {
+        strategy: 'overwrite',
+        ...options,
+    };
+    // Fetch the existing value if the strategy calls for it
+    let hasExistingValue = ['merge', 'defaults'].includes(settings.strategy)
+        ? has(target, path)
+        : undefined;
+    switch (settings.strategy) {
+        case 'set':
+        case 'overwrite':
+            _set(target, path, value);
+            break;
+        case 'merge':
+            if (hasExistingValue) {
+                merge(target, path, value);
+            }
+            else {
+                _set(target, path, value);
+            }
+            break;
+        case 'defaults':
+            defaults(target, path, value);
+            break;
+        default:
+            throw new Error(`Unknown conflict resolution strategy "${settings.strategy}"`);
+    }
+    return value;
+}
+/**
+* Internal recursive path fetcher
+*
+* @param {Object} target The target to examine
+* @param {String|Array} path The path within the target to fetch, in dotted or array notation
+* @param {*} [fallback] Optional fallback to return if the end point does not exist
+* @returns {*} The fetched value
+*/
+export function get(target, path, fallback) {
+    return _get(target, path, fallback);
+}
+/**
+* Internal recursive path checker
+*
+* @param {Object} target The target to examine
+* @param {String|Array} path The path within the target, to fetch in dotted or array notation
+* @returns {Boolean} True if the given path already exists within the subject
+*/
+export function has(target, path) {
+    return _has(target, path);
+}
+/**
+* Internal recursive path merger
+*
+* @param {Object} target The target to operate on, this is likly to be mutated
+* @param {String|Array} path The path within the target to merge, in dotted or array notation
+* @param {*} value The value to merge
+*
+* @returns {*} The merged value
+*/
+export function merge(target, path, value) {
+    _merge(get(target, path), value);
+    return value;
+}
+/**
+* Internal recursive path defaulter
+*
+* @param {Object} target The target to operate on, this is likly to be mutated
+* @param {String|Array} [path] The path within the target to merge, in dotted or array notation
+* @param {*} value The value to merge
+*
+* @returns {*} The resulting object with defaults applied
+*/
+export function defaults(target, path, value) {
+    if (typeof path == 'string' || Array.isArray(path)) { // Called as (target, path, value)
+        if (!has(target, path)) { // Target path doesn't exist at all
+            return set(target, path, value);
+        }
+        else { // Target path exists - apply Lodash defaults
+            return _defaults(get(target, path), value);
+        }
+    }
+    else { // Called as (target, value)
+        return _defaults(target, path);
+    }
+}
+// Export all functions as a lookup object
+export default {
+    set,
+    get,
+    has,
+    merge,
+    defaults,
+};
+//# sourceMappingURL=pathTools.js.map

package/dist/utils/pathTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathTools.js","sourceRoot":"","sources":["../../utils/pathTools.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,YAAY,IAAI,SAAS,EACzB,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,KAAK,IAAI,MAAM,EACf,GAAG,IAAI,IAAI,GACX,MAAM,WAAW,CAAC;AAGnB;;;;;;;EAOE;AAGF;;;;;;;;;;;;;;;EAeE;AACF,MAAM,UAAU,GAAG,CAAC,MAAW,EAAE,IAAkC,EAAE,KAAU,EAAE,OAAa;IAC7F,IAAI,QAAQ,GAAG;QACd,QAAQ,EAAE,WAAW;QACrB,GAAG,OAAO;KACV,CAAC;IAEF,wDAAwD;IACxD,IAAI,gBAAgB,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACvE,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC;QACnB,CAAC,CAAC,SAAS,CAAC;IAEb,QAAQ,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAC3B,KAAK,KAAK,CAAC;QACX,KAAK,WAAW;YACf,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAC1B,MAAM;QACP,KAAK,OAAO;YACX,IAAI,gBAAgB,EAAE,CAAC;gBACtB,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACP,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAC3B,CAAC;YACD,MAAM;QACP,KAAK,UAAU;YACd,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAC9B,MAAM;QACP;YACC,MAAM,IAAI,KAAK,CAAC,yCAAyC,QAAQ,CAAC,QAAQ,GAAG,CAAC,CAAC;IACjF,CAAC;IAGD,OAAO,KAAK,CAAC;AACd,CAAC;AAGD;;;;;;;EAOE;AACF,MAAM,UAAU,GAAG,CAAC,MAAW,EAAE,IAAkC,EAAE,QAAc;IAClF,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AACrC,CAAC;AAKD;;;;;;EAME;AACF,MAAM,UAAU,GAAG,CAAC,MAAW,EAAE,IAAkC;IAClE,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC3B,CAAC;AAGD;;;;;;;;EAQE;AACF,MAAM,UAAU,KAAK,CAAC,MAAW,EAAE,IAAkC,EAAE,KAAU;IAChF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC;AACd,CAAC;AAGD;;;;;;;;EAQE;AACF,MAAM,UAAU,QAAQ,CAAC,MAAW,EAAE,IAAwC,EAAE,KAAW;IAC1F,IAAI,OAAO,IAAI,IAAI,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,kCAAkC;QACvF,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,mCAAmC;YAC5D,OAAO,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC,CAAC,6CAA6C;YACrD,OAAO,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5C,CAAC;IACF,CAAC;SAAM,CAAC,CAAC,4BAA4B;QACpC,OAAO,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;AACF,CAAC;AAGD,0CAA0C;AAC1C,eAAe;IACd,GAAG;IACH,GAAG;IACH,GAAG;IACH,KAAK;IACL,QAAQ;CACR,CAAC"}

package/eslint.config.js

@@ -1,14 +1,50 @@
-import RulesMFDC from '@momsfriendlydevco/eslint-config';
+import RulesMFDC, {JSCommon} from '@momsfriendlydevco/eslint-config';
+import tseslint from 'typescript-eslint';
 
-export default [
+export default tseslint.config(
 	{
-		// Global ignore rules - Do not add any other keys to this object or eslint doesn't treat this as global
 		ignores: [
-			'.*',
-			'docs/',
-			'dist/',
-			'node_modules/',
+			'.*', // Ignore dotfiles/folders
+			'docs/', // Ignore documentation output
+			'dist/', // Ignore build output
+			'node_modules/', // Ignore dependencies
+			'api.md', // Ignore generated markdown API file
 		],
 	},
+
+	// Include the base configuration from MFDC
 	...RulesMFDC,
-]
+
+	// Add TypeScript specific configurations
+	{
+		// Apply these settings ONLY to .ts files
+		files: ['**/*.ts'],
+		// Use recommended TypeScript rules (includes parser/plugin setup)
+		// Using recommendedTypeChecked enables rules that require type information
+		extends: [
+			...tseslint.configs.recommendedTypeChecked,
+		],
+		// Configure the parser to find your tsconfig.json for type-aware linting
+		languageOptions: {
+			parserOptions: {
+				project: true, // Tells TS ESLint to find and use tsconfig.json
+				tsconfigRootDir: import.meta.dirname, // Helps ESLint find tsconfig.json relative to eslint.config.js
+			},
+		},
+		rules: {
+			// Add any TypeScript specific rule overrides here if needed
+			// For example:
+			// '@typescript-eslint/no-explicit-any': 'warn',
+			// '@typescript-eslint/no-unused-vars': ['warn', { 'argsIgnorePattern': '^_' }],
+			...JSCommon,
+		},
+	},
+
+	// Your existing global override - this will apply to both JS and TS files
+	// If you only want this for JS, you could add `files: ['**/*.js']` here.
+	{
+		rules: {
+			'unicorn/prefer-global-this': 'off', // Keep your specific override
+		},
+	},
+);

package/lib/{projectFile.js → projectFile.ts}

@@ -1,5 +1,16 @@
-import {filesize} from 'filesize';
-import {pick} from 'lodash-es';
+import { filesize } from 'filesize';
+import { pick } from 'lodash-es';
+import type TeraFy from './terafy.client.ts';
+
+// TODO: Refactor terafy.client.ts so that we don't need to extend the class with injected functions
+interface TeraClient extends TeraFy {
+	getProjectFileContents: (id: any, options?: any) => any
+	setProjectFileContents: (id: any, contents: any, options?: any) => any
+	getProjectLibrary: (id: any, options?: any) => any
+	setProjectLibrary: (id: any, refs:any, options?: any) => any
+};
+type SupabaseFile = any;
+type RefLibRef = any;
 
 /**
 * A project file fetched from TERA
@@ -12,7 +23,7 @@ export default class ProjectFile {
 	* @type {TeraClient}
 	* @private
 	*/
-	_tera;
+	_tera!: TeraClient;
 
 
 	/**
@@ -20,28 +31,28 @@ export default class ProjectFile {
 	* NOTE: This is computed each time from the Base64 of the file path
 	* @type {String}
 	*/
-	id;
+	id!: string;
 
 
 	/**
 	* The raw Supabase UUID of the file
 	* @type {String}
 	*/
-	sbId;
+	sbId!: string;
 
 
 	/**
 	* Relative name path (can contain prefix directories) for the human readable file name
 	* @type {String}
 	*/
-	name;
+	name!: string;
 
 
 	/**
 	* CSS class to use as the file icon
 	* @type {String}
 	*/
-	icon;
+	icon!: string;
 
 
 	/**
@@ -49,7 +60,7 @@ export default class ProjectFile {
 	* This is also used as the unique identifier within the project
 	* @type {String}
 	*/
-	path;
+	path!: string;
 
 
 	/**
@@ -57,7 +68,7 @@ export default class ProjectFile {
 	* This will usually open an edit UI within the TERA site
 	* @type {String}
 	*/
-	url;
+	url!: string;
 
 
 	/**
@@ -65,7 +76,7 @@ export default class ProjectFile {
 	* This is used to direct to the edit/view/download UI when the files project is active and is usually used in place of URL for TERA related operations
 	* @type {String}
 	*/
-	teraUrl;
+	teraUrl!: string;
 
 
 	/**
@@ -76,77 +87,83 @@ export default class ProjectFile {
 	* @property {String} ext The extension portion of the name (always lower case)
 	* @property {String} dirName The directory path portion of the name
 	*/
-	parsedName;
+	// Using 'any' for simplicity, define an interface for better type safety if desired
+	parsedName: any;
 
 
 	/**
 	* A date representing when the file was created
 	* @type {Date}
 	*/
-	created;
+	// Using Date | undefined because constructor checks if it exists
+	created: Date | undefined;
 
 
 	/**
 	* A human readable, formatted version of "created"
 	* @type {String}
 	*/
-	createdFormatted;
+	createdFormatted!: string;
 
 
 	/**
 	* A date representing when the file was created
 	* @type {Date}
 	*/
-	modified;
+	// Using Date | undefined because constructor checks if it exists
+	modified: Date | undefined;
 
 
 	/**
 	* A human readable, formatted version of "modified"
 	* @type {String}
 	*/
-	modifiedFormatted;
+	modifiedFormatted!: string;
 
 
 	/**
 	* A date representing when the file was last accessed
 	* @type {Date}
 	*/
-	accessed;
+	// Using Date | undefined because constructor checks if it exists
+	accessed: Date | undefined;
 
 
 	/**
 	* A human readable, formatted version of "accessed"
 	* @type {String}
 	*/
-	accessedFormatted;
+	accessedFormatted!: string;
 
 
 	/**
 	* Size, in bytes, of the file
 	* @type {Number}
 	*/
-	size;
+	// Using number | undefined because constructor uses `|| 0`
+	size: number | undefined;
 
 
 	/**
 	* A human readable, formatted version of the file size
 	* @type {String}
 	*/
-	sizeFormatted;
+	sizeFormatted!: string;
 
 
 	/**
 	* The associated mime type for the file
 	* @type {String}
 	*/
-	mime;
+	mime!: string;
 
 
 	/**
 	* Additional meta information for the file
 	* @type {Object}
 	*/
-	meta = {};
+	// Using Record<string, any> for a generic object, adjust if meta has a known structure
+	meta: Record<string, any> = {};
 
 
 	/**
@@ -155,12 +172,14 @@ export default class ProjectFile {
 	* @param {SupabaseFile} baseFile The basic Supabase file to extend
 	* @param {TeraFyClient} baseFile.tera The associated TeraFyClient instance to use for some file methods
 	*/
-	constructor(baseFile) {
+
+	constructor(baseFile: SupabaseFile) {
+		// Note: baseFile.tera is assumed to exist based on the check below and the SupabaseFile type definition above
 		if (!baseFile.tera) throw new Error('Basic file requires a `tera` key to access the Tera instance');
 		Object.assign(this, baseFile);
 
 		// Translate baseFile.tera -> this._tera (non-enumerable, non-configurable)
-		const tera = this.tera;
+		const tera = (this as any).tera;
 		Object.defineProperty(this, '_tera', {
 			enumerable: false,
 			configurable: false,
@@ -169,13 +188,15 @@ export default class ProjectFile {
 				return tera;
 			},
 		});
-		delete this.tera; // Remove original ref we merged above
+
+		delete (this as any).tera; // Remove original ref we merged above
 
 		// Calculate `teraUrl` from URL
+		// Assuming this.url is always defined after Object.assign
 		this.teraUrl = this.url.replace(/^https?:\/\/(?:.+?)\/projects\/(?:.+?)\/project\/(.+)$/, '/project/$1');
 
 		// Set all `*Formatted` fields
-		this.sizeFormatted = filesize(this.size || 0, {spacer: ''});
+		this.sizeFormatted = filesize(this.size || 0, { spacer: '' });
 		this.createdFormatted = this.created ? this.created.toLocaleDateString() : 'Unknown created date';
 		this.modifiedFormatted = this.modified ? this.modified.toLocaleDateString() : 'Unknown modified date';
 		this.accessedFormatted = this.accessed ? this.accessed.toLocaleDateString() : 'Unknown access date';
@@ -187,11 +208,13 @@ export default class ProjectFile {
 	*
 	* @param {Object} [options] Additioanl options to mutate behaviour
 	*
-	* @returns {Blob} The eventual raw file contents as a Blob
+	* @returns {Promise<Blob>} The eventual raw file contents as a Blob
 	*
 	* @see getProjectFile()
 	*/
-	getContents(options) {
+
+	getContents(options?: any): Promise<Blob> {
+		// Assuming _tera has this method and it returns Promise<Blob>
 		return this._tera.getProjectFileContents(this.id, options);
 	}
 
@@ -201,11 +224,13 @@ export default class ProjectFile {
 	*
 	* @param {File|Blob|FormData|Object|Array} contents The new file contents
 	*
-	* @returns {Promise} A promise which resolves when the operation has completed
+	* @returns {Promise<void>} A promise which resolves when the operation has completed
 	*
 	* @see setProjectFileContents()
 	*/
-	setContents(contents) {
+
+	setContents(contents: File | Blob | FormData | object | any[]): Promise<void> {
+		// Assuming _tera has this method and it returns Promise<void> or similar
 		return this._tera.setProjectFileContents(this.id, contents, {});
 	}
 
@@ -213,11 +238,13 @@ export default class ProjectFile {
 	/**
 	* Fetch the file contents as an array of Reflib refs
 	*
-	* @returns {Promise<Array<Ref>>} An eventual array of RefLib references
+	* @returns {Promise<Array<RefLibRef>>} An eventual array of RefLib references
 	*
 	* @see getProjectLibrary()
 	*/
-	getRefs() {
+
+	getRefs(): Promise<Array<RefLibRef>> {
+		// Assuming _tera has this method and it returns Promise<Array<RefLibRef>>
 		return this._tera.getProjectLibrary(this.id);
 	}
 
@@ -227,11 +254,13 @@ export default class ProjectFile {
 	*
 	* @param {Array<RefLibRef>} refs Collection of references for the selected library
 	*
-	* @returns {Promise} A promise which resolves when the operation has completed
+	* @returns {Promise<void>} A promise which resolves when the operation has completed
 	*
 	* @see setProjectLibrary()
 	*/
-	setRefs(refs) {
+
+	setRefs(refs: Array<RefLibRef>): Promise<void> {
+		// Assuming _tera has this method and it returns Promise<void> or similar
 		return this._tera.setProjectLibrary(this.id, refs);
 	}
 
@@ -243,7 +272,8 @@ export default class ProjectFile {
 	* @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
 	* @returns {Object} A Structured Clone compatible representation of this ProjectFile instance
 	*/
-	serialize() {
+
+	serialize(): Partial<ProjectFile> { // Using Partial<ProjectFile> as it returns a subset
 		return pick(this, [
 			'id',
 			'sbId',
@@ -265,13 +295,25 @@ export default class ProjectFile {
 
 	/**
 	* Restore an entity created with serialize
+	* NOTE: This requires the 'tera' instance to be manually added to the 'data' object before calling deserialize,
+	*       as it's not included in the serialized output.
 	*
-	* @param {Object} data An input object created via `ProjectFiles.serialize()`
+	* @param {Object} data An input object created via `ProjectFiles.serialize()` (MUST include a 'tera' property added manually)
 	* @returns {ProjectFile} A ProjectFile instance setup against the deserializzed data
 	*/
-	static deserialize(data) {
-		return new ProjectFile(pick(data, [
-			'tera',
+
+	static deserialize(data: any): ProjectFile {
+		// TODO: Check the below
+		// WARNING: The original 'serialize' method does NOT include 'tera'.
+		// The caller of 'deserialize' MUST add the correct 'tera' instance to the 'data' object
+		// before passing it here, otherwise the constructor will fail.
+		// e.g., const serializedData = file.serialize();
+		//       serializedData.tera = myTeraClientInstance;
+		//       const restoredFile = ProjectFile.deserialize(serializedData);
+
+		// This pick includes 'tera', assuming it was added to 'data' externally.
+		const constructorArg = pick(data, [
+			'tera', // Assumes 'tera' exists on the input 'data' object
 			'id',
 			'sbId',
 			'name',
@@ -285,6 +327,7 @@ export default class ProjectFile {
 			'size',
 			'mime',
 			'meta',
-		]));
+		]);
+		return new ProjectFile(constructorArg);
 	}
-}
+}