npm - cradova - Versions diffs - 1.0.0 - Mend

cradova 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/index.ts ADDED Viewed

@@ -0,0 +1,366 @@
+/*         _____
+ *        /     \
+ *       /   /\  \
+ *      /   /  \__\
+ *     /   /    _    _
+ *    /   /    (_)  (_)
+ *   (    \    ___
+ *    \    \  /  /
+ *     \    \/  /
+ *      \      /
+ *       \____/
+ *
+ *   Cradova FrameWork
+ *     @version 1.0.0
+        @licence Apache v2
+ @publisher : Friday Candour;
+ @project : Cradova Framework;
+ @copyright-lincense :  Apache v2;
+ email > fridaymaxtour@gmail.com
+ github > www.github.com/FridayCandour
+ telegram > @uiedbooker
+                                  Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+ *       Copyright 2022 Friday Candour. All Rights Reserved.
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *       You may obtain a copy of the License at
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ *
+*/
+import css from "./scripts/css.js";
+import w from "./scripts/widget.js";
+import Init from "./scripts/init.js";
+import swipe from "./scripts/swipe.js";
+import media from "./scripts/media.js";
+import Store from "./scripts/store.js";
+import Router from "./scripts/Router.js";
+import Screen from "./scripts/Screen.js";
+import JSONDB from "./scripts/JsonDB.js";
+import Speaker from "./scripts/speaker.js";
+import animate from "./scripts/animate.js";
+import fs from "./scripts/file-system.js";
+import ls from "./scripts/localStorage.js";
+import dispatch from "./scripts/dispatcher.js";
+import fullScreen from "./scripts/fullscreen.js";
+import metrics from "./scripts/Metrics.js";
+("use strict");
+/**
+ * Acts as a function or object depending on how it is referenced.
+ *
+ * :: schemes
+ *  @example
+ *  // creating html elements
+ * @param  element_initials | <html template string, props object?, children?>.
+ * @returns Cradova element base function.
+ * @example
+ * // html template strings examples
+ *
+ * //template literals example, can't accept props object or children
+ *
+ * _`p| am a p tag`
+ * // equivilent <p> am a p tag</p>
+ *
+ * or _`p.class| am a p tag`
+ * // equivilent <p class="class"> am a p tag </p>
+ *
+ * or _`p#id| am a p tag`
+ * // equivilent <p id="id"> am a p tag </p>
+ *
+ * or _`p.class#id| am a p tag`
+ * // equivilent <p id="id" class="class"> am a p tag </p>
+ *
+ * // using props and children
+ *
+ *  _("p| am a p tag" ,{
+ *  //props like
+ *  text: "am a dynamic paragraph tag", // this will override text value above
+ *  style: {
+ *   color: "blue"
+ *  }
+ * },
+ * // place other children here like span
+ * _`span| am a span tag like so`,
+ * _("span| am a span tag like so", {style: {color: "brown"}})
+ * )
+ *
+ * every other cradova methods like _.dispatch, _.reuse ... can be distructured
+ * vist the docs for more info.
+ * Enjoy!
+ */
+const _ = (...element_initials: { raw: any }[]) => {
+  let properties: { [x: string]: any },
+    childrens: string | any[] = [];
+  // getting props and children set
+  if (
+    typeof element_initials[1] == "object" &&
+    !(element_initials[1] instanceof HTMLElement)
+  ) {
+    properties = element_initials[1];
+    if (element_initials.length > 2) {
+      childrens = element_initials.slice(2, element_initials.length);
+    }
+  } else {
+    if (
+      element_initials[1] instanceof HTMLElement ||
+      typeof element_initials[1] === "function"
+    ) {
+      childrens = element_initials.slice(1, element_initials.length);
+    }
+  }
+  // don't move this up
+  if (typeof element_initials[0] === "string") {
+    element_initials = element_initials[0];
+  }
+  // verifing the children array
+  for (let i = 0; i < childrens.length; i++) {
+    if (
+      !(childrens[i] instanceof HTMLElement) &&
+      typeof childrens[i] !== "function"
+    ) {
+      throw new Error(
+        "cradova err invalid children list, should be a Cradova element base  " +
+          childrens[i]
+      );
+    }
+  }
+  /**
+   * sorts props and creates cradova element base
+   * @param element_initials
+   * @returns cradova element base
+   */
+  function identify(element_initials: any[]) {
+    if (typeof element_initials !== "object") {
+      element_initials = [element_initials];
+    }
+    // getting element id, class and text value if available
+    let tag, className, ID;
+    const [el, innerValue] = element_initials[0].split("|");
+    if (el.indexOf("#") > -1) {
+      ID = el.split("#")[1];
+      tag = el.split("#")[0];
+      className = ID.split(".")[1];
+      if (className) {
+        ID = ID.split(".")[0];
+      }
+    }
+    if (el.indexOf(".") > -1) {
+      if (!className) {
+        className = el.split(".")[1];
+        tag = el.split(".")[0];
+        let locID = className.split("#")[1];
+        if (locID) {
+          className = className.split("#")[0];
+        }
+      }
+    }
+    if (tag === "") {
+      tag = "div";
+    }
+    if (!tag && tag !== "") {
+      tag = el;
+    }
+    const initials = { tag, className, ID, innerValue };
+    /**
+     * params [incoming]:any elements and props object
+     * @returns HTML element
+     */
+    return (...incoming: string | any[]) => {
+      let childrens2rd = [],
+        props = {},
+        text;
+      for (let i = 0; i < incoming.length; i++) {
+        if (
+          typeof incoming[i] === "function" ||
+          incoming[i] instanceof HTMLElement
+        ) {
+          childrens2rd.push(incoming[i]);
+          continue;
+        }
+        //
+        if (
+          !(incoming[i] instanceof HTMLElement) &&
+          typeof incoming[i] === "object"
+        ) {
+          props = incoming[i];
+          continue;
+        }
+        if (typeof incoming[i] === "string") {
+          text = incoming[i];
+          continue;
+        }
+        //
+        if (childrens[0]) {
+          if (childrens2rd) {
+            childrens2rd.push(...childrens);
+          } else {
+            childrens2rd = childrens;
+          }
+          continue;
+        }
+      }
+      const element = document.createElement(initials.tag);
+      if (initials.className) {
+        element.className = initials.className;
+      }
+      if (initials.ID) {
+        element.id = initials.ID;
+      }
+      if (initials.innerValue) {
+        element.append(initials.innerValue);
+      }
+      for (const prop in properties) {
+        if (prop === "style") {
+          for (const [k, v] of Object.entries(properties[prop])) {
+            element.style[k] = v;
+          }
+          continue;
+        }
+        if (prop === "class") {
+          element.classList.add(properties[prop]);
+          continue;
+        }
+        if (prop === "text") {
+          element.innerText = properties[prop];
+          continue;
+        }
+        element[prop] = properties[prop];
+      }
+      // over-rides props that appear in the first level
+      if (props && typeof props === "object" && !Array.isArray(props)) {
+        for (const prop in props) {
+          if (prop === "style") {
+            for (const [k, v] of Object.entries(props[prop])) {
+              element.style[k] = v;
+            }
+            continue;
+          }
+          if (prop === "text") {
+            element.innerText = props[prop];
+            continue;
+          }
+          if (prop === "class") {
+            element.classList.add(props[prop]);
+            continue;
+          }
+          if (prop === "fullscreen") {
+            if (properties[prop]) {
+              fullScreen(element).set();
+            } else {
+              fullScreen(element).exist();
+            }
+            continue;
+          }
+          element[prop] = props[prop];
+        }
+      }
+      // building parent tree if children are available
+      if (childrens2rd && childrens2rd[0]) {
+        for (let i = 0; i < childrens2rd.length; i++) {
+          if (typeof childrens2rd[i] === "function") {
+            element.append(childrens2rd[i]());
+            continue;
+          }
+          element.append(childrens2rd[i]);
+        }
+      }
+      // adds text content if available
+      if (text) {
+        element.append(text);
+      }
+      if (element.stateID) {
+        // adding cradova dynamic state signature as class name
+        element.classList.add("cra_child_doc");
+      }
+      return element;
+    };
+  }
+  if (element_initials[0].raw) {
+    element_initials = identify(element_initials[0].raw);
+  } else {
+    element_initials = identify(element_initials);
+  }
+  return element_initials;
+};
+_.register = (name: any) => {
+  for (const key in name) {
+    _[key] = name[key];
+  }
+};
+/**
+ * registering added methods to the cradova object _
+ *
+ * these can be safely destructured to use alone
+ */
+_.register({
+  w,
+  css,
+  Init,
+  media,
+  swipe,
+  Store,
+  JSONDB,
+  Screen,
+  Router,
+  LS: ls,
+  FS: fs,
+  Speaker,
+  metrics,
+  animate,
+  dispatch,
+  //  App: window.app,
+  globalState: { state: {}, stateID: "" },
+});
+_.Init();
+window._ = _;
+export default _;
+/**
+ *
+ * Registering ServiceWorker
+ *
+ *  */
+window.addEventListener("load", async () => {
+  if ("serviceWorker" in navigator) {
+    await navigator.serviceWorker
+      .register("service-worker.js")
+      .then(function (registration) {
+        // Registration was successful
+        //         console.log(
+        //           `Service Worker registration successful. Scope: ${registration.scope}
+        // comment this line out at nodemodules/cradova/index.js line 362`
+        //         );
+      })
+      .catch((err) => console.log(err));
+  }
+});

package/package.json ADDED Viewed

@@ -0,0 +1,36 @@
+{
+  "name": "cradova",
+  "version": "1.0.0",
+  "description": "Web framework for building web apps and PWAs",
+  "main": "index.js",
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FridayCandour/cradova.git"
+  },
+  "keywords": [
+    "framework",
+    "javascript",
+    "typescript",
+    "web",
+    "app",
+    "PWA",
+    "android",
+    "IOS",
+    "windows",
+    "linux",
+    "mac"
+  ],
+  "author": "fridaycandour",
+  "license": "Apache-2.0",
+  "types": "./index.d.ts",
+  "bugs": {
+    "url": "https://github.com/FridayCandour/cradova/issues"
+  },
+  "homepage": "https://github.com/FridayCandour/cradova#readme"
+}

package/scripts/JsonDB.d.ts ADDED Viewed

@@ -0,0 +1,298 @@
+/**
+ *     JSON DB DataBase MIT Licence © 2022
+ *     ************************************
+ *     Created by Friday Candour @uiedbooker
+ *     email > fridaymaxtour@gmail.com
+ *     github > www.github.com/FridayCandour
+ *      telegram > @uiedbooker
+ *   JSONDB  @version 1.0.0
+ *  */
+export declare const JSONDBversion = "1.0.0";
+declare class JSONDBTableWrapper {
+    put: (name: string, value: any) => Promise<void>;
+    get: (name: string) => Promise<unknown>;
+    validator: (incoming: {
+        [x: string]: any;
+    }, tables: string | any[]) => {};
+    self: any;
+    keys: any;
+    constructor(self: unknown, keys: any);
+    /**
+   * Save with relations
+   * ---------------------
+   * @type     .saveWithRelations(target table, schema, schema | schema[]) => Promise(object)
+   * @example
+    * // single relation
+  await PollTable.saveWithRelations(MessageTable, Poll, message);
+  // arrays of relations
+  await PollTable.saveWithRelations(MessageTable, Poll, allMessages);
+  */
+    saveWithRelations(table: {
+        self: {
+            name: string | number;
+        };
+    }, incoming: {
+        index: string | number;
+    }, relations: string | any[]): Promise<any>;
+    /**
+   * Save table into a Jsondb instance
+   * -----------------------------
+   * @type .save(schema)=> Promise(object)
+   * @example
+   await PollTable.save(poll)
+  */
+    save(incoming: {
+        index: number;
+        relations: {};
+    }): Promise<{
+        index: number;
+        relations: {};
+    }>;
+    /**
+   * Save table into a Jsondb instance
+   * -----------------------------
+   * @type .remove(schema)=> Promise(object)
+   * @example
+   await PollTable.remove(poll)
+  */
+    remove(entity: {
+        index: string | number;
+    }): Promise<void>;
+    /**
+   * Save table into a Jsondb instance
+   * -----------------------------
+   * @type .count(schema)=> Promise(number)
+   * @example
+   await PollTable.count(poll)
+  */
+    count(): Promise<any>;
+    /**
+   * Save table into a Jsondb instance
+   * -----------------------------
+   * @type .getAll()=> Promise(object[])
+   * @example
+   await PollTable.getAll()
+  */
+    getAll(): Promise<any>;
+    /**
+   * get entities with any of the values specifiled from a Jsondb instance
+   * -----------------------------
+   * @type .getWhereAny({prop: value}, number | undefind)=> Promise(object)
+   * @example
+   await PollTable.getWhereAny({name: "friday", age: 121, class: "senior"}) // gets all
+   await PollTable.getWhereAny({email: "fridaymaxtour@gmail.com"}, 2) // gets 2 if they are up to two
+  */
+    getWhereAny(props: {
+        [s: string]: unknown;
+    } | ArrayLike<unknown>, number: number): Promise<any[]>;
+    /**
+   * get entities with the given prop of type "string" where the values specifiled is included
+   * -----------------------------
+   * @type .getWhereAnyPropsIncludes({prop: value}, number | undefind)=> Promise(object)
+   *
+   * @example prop must be type string!
+   *
+   await PollTable.getWhereAnyPropsIncludes({name: "fri"}) // gets all
+   await PollTable.getWhereAnyPropsIncludes({name: "fri"}, 2) // gets 2 if they are up to two
+  */
+    getWhereAnyPropsIncludes(props: {
+        [s: string]: unknown;
+    } | ArrayLike<unknown>, number: number): Promise<any[]>;
+    /**
+   * get an entity with the values specifiled from a Jsondb instance
+   * -----------------------------
+   * @type .getOne({prop: value})=> Promise(object)
+   * @example
+    await PollTable.getOne({email: "fridaymaxtour@gamail.com"}) // gets one
+    */
+    getOne(props: {
+        [s: string]: unknown;
+    } | ArrayLike<unknown>): Promise<any>;
+}
+/**
+ * Create a new JSONDB object
+ *------------------------
+ *  @class
+ * const database = new JSONDB()
+ *
+ * Creates a new JSONDB object
+ *
+ * .
+ * */
+declare class JSONDB {
+    DB_NAME: string;
+    username: string;
+    encrypted: boolean;
+    initialised: boolean;
+    time_created: string;
+    version: string;
+    last_access_time: string;
+    visuality: string;
+    Entities: {};
+    tables: {};
+    password: string;
+    constructor();
+    getDB(name: string): Promise<unknown>;
+    /**
+   * Schema constructor for Jsondb
+   * -----------------------------
+   *
+   * name @type string
+   *
+   * columns @type object  {
+   *
+   * type >  @type any of  number > string > boolean > blob and must be specified
+   *
+   * nullable @type bolean true > false default false
+   *
+   * unique  @type bolean   true > false default false
+   *
+   * }
+   *
+   * relations @type object {
+   *
+   * target: entity schema @type object,
+   *
+   *  attachment_name: @type string,
+   *
+   * type : @type string should be "many" or "one"
+   *
+   *  }
+   *
+   *
+   *
+   * @example
+   *
+   * const MessageSchema = database.schema({
+    name: "Message",
+    columns: {
+      vote: {
+        type: "number",
+      },
+      time: {
+        type: "string",
+        nullable: true,
+      },
+      value: {
+        type: "string",
+      },
+    },
+  });
+   *
+   * const PollSchema = new JSONDB.schema({
+    name: "Poll",
+    columns: {
+      value: {
+        type: "varchar",
+      },
+    },
+    relations: {
+      Message: {
+        target: Message,
+        type: "many-to-one",
+      },
+    },
+  });
+   */
+    schema(schema_configuration_object: Record<string, string>): {
+        base_name: string;
+        name: string;
+        last_index: number;
+        columns: string;
+        relations: string;
+    };
+    /**
+     * Create a new JSONDB instance
+     *------------------------
+     *  @example
+     * // creates a JSONDB object
+     * const Database = new JSONDB()
+     * // database configuration object
+     * const config = {
+     DB_NAME: "my db",
+    password: "password",
+    username: "jsondb_username",
+   encrypted: false,
+      }
+   // Creates a new JSONDB instance
+     * Database.init(config)
+     * */
+    init(config: {
+        name: string;
+        password: string;
+        username: string;
+        encrypted: boolean;
+    }): void;
+    /**
+   * Create secure connection a Jsondb instance
+   * -----------------------------
+   * @example
+   *
+   * const details = {
+    password: "password",
+    username: "jsondb_username",
+  };
+  const connection = await database.createJSONDBConnection(details);
+  */
+    createJSONDBConnection(details: {
+        username: any;
+        password: any;
+    }): Promise<{
+        Entities: any;
+        keys: any;
+        /**
+         * Get a table from JSONDB
+         *------------------------
+         * @example
+         *
+         *
+      const details = {
+        password: "password",
+        username: "jsondb_username",
+      };
+      // getting connection instance into JSONDB
+      const connection = await database.createJSONDBConnection(details);
+      // getting a table
+      const MessageTable = connection.getTable("Message");
+         * */
+        getTable(table_name: string): JSONDBTableWrapper;
+    }>;
+    validateRelations(relations: {
+        [s: string]: unknown;
+    } | ArrayLike<unknown>): void;
+    validateColumns(columns: {
+        [s: string]: unknown;
+    } | ArrayLike<unknown>): void;
+    /**
+   * Assemble Entities into Jsondb
+   * -----------------------------
+   * @example
+   *
+   * const MessageSchema = database.schema({
+    name: "Message",
+    columns: {
+      vote: {
+        type: "number",
+      },
+      time: {
+        type: "string",
+        nullable: true,
+      },
+      value: {
+        type: "string",
+      },
+    },
+  });
+  database.assemble([MessageSchema]);
+  *
+  */
+    assemble(allEntities: string | any[]): void;
+}
+/**
+ * @exports
+ */
+export default JSONDB;