this.me 2.9.4 → 2.9.5

package/src/methods/attributes.js

@@ -0,0 +1,79 @@
+ // Attributes methods
+ /**
+ * @module Attributes
+ * @description Methods to manage attributes for the `Me` class, with key-vaue pairs.
+ */
+/**
+   * @description Adds or updates an attribute for the `me` instance.
+   * 
+   * This method allows you to dynamically add or update descriptive attributes 
+   * for the `me` instance. Attributes are stored as key-value pairs, where:
+   * - The **key** represents the name of the attribute (e.g., "name", "age", "location").
+   * - The **value** represents the data associated with that attribute (e.g., "Sui Gn", 30, "Earth").
+   * 
+   * You can add as many key-value pairs as you want, giving you the flexibility to describe 
+   * the `me` instance with plain data. The attributes are stored in an object, and each call 
+   * to `be` either adds a new attribute or updates an existing one if the key already exists.
+   * 
+   * This approach ensures that the `me` instance can evolve and be customized over time 
+   * with additional or modified attributes as needed.
+   * 
+   * @param {string} key - The attribute key (e.g., "name").
+   * @param {string|number|boolean|Object} value - The attribute value associated with the key. 
+   *   This can be any data type (e.g., string, number, boolean, or even a nested object).
+   * 
+   * @example
+   * // Adding a single attribute
+   * me.be("name", "Sui Gn");
+   * console.log(me.getAttributes()); // { name: "Sui Gn" }
+   * 
+   * // Adding multiple attributes
+   * me.be("age", 30);
+   * me.be("location", "Earth");
+   * console.log(me.getAttributes()); 
+   * // Output: { name: "Sui Gn", age: 30, location: "Earth" }
+   * 
+   * // Updating an existing attribute
+   * me.be("name", "John Doe");
+   * console.log(me.getAttributes()); 
+   * // Output: { name: "John Doe", age: 30, location: "Earth" }
+   * 
+   * // Using complex data types
+   * me.be("preferences", { theme: "dark", language: "en" });
+   * console.log(me.getAttributes());
+   * // Output: { name: "John Doe", age: 30, location: "Earth", preferences: { theme: "dark", language: "en" } }
+   */
+export function be(attributes, key, value) {
+    if (!key || typeof key !== 'string') {
+        throw new Error('Invalid key for attribute');
+    }
+    attributes[key] = value;
+  }
+  /**
+     * @description Retrieves all attributes associated with the `me` instance.
+     * 
+     * This method provides access to the current set of attributes stored in the `me` instance 
+     * as an object containing key-value pairs. Each key represents the name of an attribute, 
+     * and its corresponding value represents the data stored for that attribute.
+     * 
+     * You can either:
+     * - Retrieve all attributes at once as a single object.
+     * - Access specific attributes directly using their keys.
+     * 
+     * @returns {Object} An object containing all the key-value pairs representing 
+     * the attributes of the `me` instance.
+     * 
+     * @example
+     * // Retrieving all attributes
+     * console.log(me.getAttributes()); 
+     * // Output: { name: "Sui Gn", age: 30, location: "Earth" }
+     * 
+     * // Accessing specific attributes by their key
+     * const attributes = me.getAttributes();
+     * console.log(attributes.name); // "Sui Gn"
+     * console.log(attributes.age); // 30
+     * console.log(attributes.location); // "Earth"
+     */
+  export function getAttributes(attributes) {
+    return attributes;
+  }

package/src/methods/identity.js

@@ -0,0 +1,31 @@
+/**
+ * @module Identity
+ * @description Methods to manage identity for the `Me` class.
+ */
+
+/**
+ * Sets up the identity for a `Me` instance.
+ * @function
+ * @param {string} username - The username to set for the identity.
+ * @returns {Object} The identity object containing the username.
+ * 
+ * @example
+ * const identity = setup("suiGn");
+ * console.log(identity); // { username: "suiGn" }
+ */
+export function setup(username) {
+  return { username };
+}
+
+/**
+* Retrieves the username (identity) of the `Me` instance.
+* @function
+* @param {Object} identity - The identity object of the `Me` instance.
+* @returns {Object} The `Me` username identity object.
+* 
+* @example
+* console.log(getMe({ username: "suiGn" })); // { username: "suiGn" }
+*/
+export function getMe(identity) {
+  return identity;
+}

package/src/methods/properties.js

@@ -0,0 +1,73 @@
+// this.me/src/methods/properties.js
+/**
+ * @module Properties
+ * @description Methods to manage properties for the `Me` class.
+ */
+
+/**
+ * Validates a property before adding it.
+ * @function
+ * @param {Object} property - The property to validate.
+ * @throws {Error} If the property is invalid.
+ */
+function validateProperty(property) {
+  if (!property || typeof property !== 'object') {
+    throw new Error('Invalid property: Must be a non-null object.');
+  }
+}
+
+/**
+ * Adds a property to the identity.
+ * @function
+ * @param {Array} properties - The properties array to update.
+ * @param {Object} property - The property to add (e.g., { type: "ETH", address: "0x123..." }).
+ */
+function addProperty(properties, property) {
+  validateProperty(property);
+  properties.push(property);
+}
+
+/**
+ * Retrieves all properties for the identity.
+ * @function
+ * @param {Array} properties - The properties array to retrieve from.
+ * @returns {Array} The properties array.
+ */
+function getProperties(properties) {
+  return [...properties]; // Return a shallow copy to prevent mutation outside
+}
+
+/**
+ * Removes a property from the identity.
+ * @function
+ * @param {Array} properties - The properties array to update.
+ * @param {Object} property - The property to remove.
+ */
+function removeProperty(properties, property) {
+  validateProperty(property);
+  const index = properties.findIndex(p => JSON.stringify(p) === JSON.stringify(property));
+  if (index !== -1) properties.splice(index, 1);
+}
+
+/**
+ * Checks if a specific property exists.
+ * @function
+ * @param {Array} properties - The properties array.
+ * @param {Object} property - The property to check.
+ * @returns {boolean} True if the property exists, otherwise false.
+ */
+function hasProperty(properties, property) {
+  validateProperty(property);
+  return properties.some(p => JSON.stringify(p) === JSON.stringify(property));
+}
+
+// Named exports
+export { addProperty, getProperties, removeProperty, hasProperty };
+
+// Default export (optional for easier import as an object)
+export default {
+  addProperty,
+  getProperties,
+  removeProperty,
+  hasProperty
+};

package/src/methods/reactions.js

@@ -0,0 +1,31 @@
+//this.me/src/methods/reactions.js
+/**
+ * @module Reactions
+ * @description Methods to manage reactions for the `Me` class.
+ */
+/**
+ * Add a reaction to a target.
+ * @function
+ * @param {Array} reactions - The reactions array to update.
+ * @param {string} type - The type of reaction (e.g., "like", "comment").
+ * @param {string} target - The target of the reaction (e.g., "PostID").
+ * @param {string} [content=null] - Additional content for the reaction (e.g., a comment).
+ * @throws {Error} If the type or target is invalid.
+ */
+export function react(reactions, type, target, content = null) {
+    if (!type || !target) {
+      throw new Error('Invalid reaction parameters');
+    }
+    reactions.push({ type, target, content, timestamp: new Date() });
+  }
+  
+  /**
+   * Retrieve all reactions for the identity.
+   * @function
+   * @param {Array} reactions - The reactions array to retrieve from.
+   * @returns {Array} The reactions array.
+   * @instance
+   */
+  export function getReactions(reactions) {
+    return reactions;
+  }

package/src/methods/relationships.js

@@ -0,0 +1,26 @@
+/**
+ * @module Relationships
+ * @description Manages user relationships.
+ */
+
+// Function to add a relationship
+export function addRelationship(relationships, relationship) {
+  if (!relationship || !relationship.type || !relationship.username) {
+    throw new Error('Invalid relationship object. Must include type and username.');
+  }
+
+  relationships.push(relationship);
+}
+
+// Function to retrieve relationships
+export function getRelationships(relationships, type = null) {
+  if (type) {
+    return relationships.filter(rel => rel.type === type);
+  }
+  return relationships;
+}
+
+// Function to initialize relationships for a user
+export function createRelationships() {
+  return [];
+}

package/src/scripts/setup.js

@@ -0,0 +1,19 @@
+// setup.js
+import { mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+const root = path.join(homedir(), '.this');
+const mePath = path.join(root, 'me');
+if (!existsSync(root)) {
+  mkdirSync(root);
+  console.log('✅ Created ~/.this root directory');
+} else {
+  console.log('✅ ~/.this root directory already exists');
+}
+
+if (!existsSync(mePath)) {
+  mkdirSync(mePath);
+  console.log('✅ Created ~/.this/me directory');
+} else {
+  console.log('✅ ~/.this/me directory already exists');
+}

package/src/scripts/setup_validation.js

@@ -0,0 +1,31 @@
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+const root = path.join(homedir(), '.this');
+const mePath = path.join(root, 'me');
+
+export function validateSetup() {
+  let updated = false;
+
+  if (!existsSync(root)) {
+    mkdirSync(root);
+    console.log('✅ Created ~/.this root directory');
+    updated = true;
+  }
+
+  if (!existsSync(mePath)) {
+    mkdirSync(mePath);
+    console.log('✅ Created ~/.this/me directory');
+    updated = true;
+  }
+
+  if (!updated) {
+    console.log('.me >> init.');
+  }
+}
+
+// Run directly if script is executed as entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+  validateSetup();
+}

package/src/.me.cli.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-//.me.cli.js
-import { program } from 'commander';
-import { meMainChoices } from './CLI/me_MainChoices.js';
-import AddMe from './CLI/AddMe.js'; 
-import LogMe from './CLI/LogMe.js'; 
-program
-  .description('.Me Command Line Interface')
-  .version('1.0.0')
-  .action(meMainChoices);
-
-program.command('add-me')
-  .description('+ Add .me')
-  .action(AddMe);
-
-program.command('log-me')
-  .description('Log .me')
-  .action(LogMe);
-
-program.parse(process.argv);