@imbricate/core 3.8.0 → 3.8.2

package/.yarnrc.yml

@@ -1,3 +0,0 @@
-nodeLinker: node-modules
-
-yarnPath: .yarn/releases/yarn-4.4.0.cjs

package/babel.config.js

@@ -1,14 +0,0 @@
-module.exports = {
-    presets: [
-        [
-            "@babel/preset-env",
-            {
-                targets:
-                {
-                    node: "current",
-                },
-            },
-        ],
-        "@babel/preset-typescript",
-    ],
-};

package/docs/README.md

@@ -1,70 +0,0 @@
-# Imbricate ▦
-
-```
-┌───────┐
-│ I M B │
-│ R I C │
-│ A T E │
-└───────┘
-```
-
-[![Continuous Integration](https://github.com/Imbricate/Imbricate/actions/workflows/ci.yml/badge.svg)](https://github.com/Imbricate/Imbricate/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/Imbricate/Imbricate/branch/main/graph/badge.svg)](https://codecov.io/gh/Imbricate/Imbricate)
-[![npm version](https://badge.fury.io/js/%40imbricate%2Fcore.svg)](https://badge.fury.io/js/%40imbricate%2Fcore)
-[![downloads](https://img.shields.io/npm/dm/@imbricate/core.svg)](https://www.npmjs.com/package/@imbricate/core)
-
-Yes to accountable notes, no to external hosting. Free, for everyone.
-
-## Install
-
-```sh
-yarn add @imbricate/core
-# Or
-npm install @imbricate/core --save
-```
-
-## Documentation
-
-Visit [imbricate.io](https://imbricate.io/).
-
-## Quick Start with Imbricate VSCode Extension
-
-Imbricate VSCode Extension is available through the Visual Studio Code Marketplace. See [Imbricate VSCode Extension](https://marketplace.visualstudio.com/items?itemName=imbricate.imbricate).
-
-## Quick Start with Imbricate CLI
-
-Imbricate CLI is available through NPM for package management. See https://github.com/imbricate/Imbricate-CLI.
-
-To install Imbricate CLI:
-
-### Using Yarn
-
-Yarn 1.x
-
-```sh
-yarn global add imbricate
-```
-
-Yarn 2.x
-
-```sh
-yarn dlx imbricate
-```
-
-### Using NPM
-
-```sh
-npm install -g imbricate
-```
-
-## Usage
-
-```sh
-imbricate --help
-```
-
-```
-┌─────────────────────┐
-│ I M B R I C A T E ▦ │
-└─────────────────────┘
-```

package/eslint.config.mjs

@@ -1,64 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import typescriptParser from "@typescript-eslint/parser";
-
-export default [
-    {
-        files: ["**/*.{ts,tsx}"],
-        languageOptions: {
-            parser: typescriptParser,
-            parserOptions: {
-                sourceType: "module",
-            },
-        },
-    },
-    {
-        plugins: {
-            "@typescript-eslint": typescriptEslint,
-        },
-        rules: {
-            "@typescript-eslint/no-explicit-any": "off",
-            "@typescript-eslint/no-unused-vars": [
-                "error",
-                {
-                    "argsIgnorePattern": "^_",
-                },
-            ],
-            "comma-dangle": [
-                "error",
-                {
-                    arrays: "always-multiline",
-                    objects: "always-multiline",
-                    functions: "always-multiline",
-                    imports: "always-multiline",
-                    exports: "always-multiline",
-                },
-            ],
-            "sort-imports": [
-                "error",
-                {
-                    ignoreCase: false,
-                    ignoreDeclarationSort: true,
-                    ignoreMemberSort: false,
-                    allowSeparatedGroups: false,
-                    memberSyntaxSortOrder: [
-                        "none",
-                        "all",
-                        "multiple",
-                        "single",
-                    ],
-                },
-            ],
-            quotes: [
-                "error",
-                "double",
-                {
-                    avoidEscape: true,
-                },
-            ],
-            semi: [
-                "error",
-                "always",
-            ],
-        },
-    },
-];

package/jest.config.ts

@@ -1,14 +0,0 @@
-import type { Config } from "jest";
-
-export default async (): Promise<Config> => {
-    return {
-        verbose: true,
-        collectCoverageFrom: [
-            "src/**/*.ts",
-        ],
-        coverageReporters: [
-            "json",
-            "text-summary",
-        ],
-    };
-};

package/src/database/schema.ts

@@ -1,165 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Database
- * @description Schema
- */
-
-import { IMBRICATE_PROPERTY_TYPE } from "../document/property";
-
-export type ImbricateDatabaseSchemaProperty<T extends IMBRICATE_PROPERTY_TYPE> = {
-
-    readonly propertyIdentifier: string;
-} & ImbricateDatabaseSchemaPropertyForCreation<T>;
-
-export type ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase = {
-
-    readonly originUniqueIdentifier: string;
-    readonly databaseUniqueIdentifier: string;
-};
-
-export type ImbricateDatabaseSchemaPropertyOptionsLabelOption = {
-
-    readonly labelIdentifier: string;
-    readonly labelName: string;
-
-    readonly labelColor: string;
-};
-
-export type ImbricateDatabaseSchemaPropertyOptionsLabel = {
-
-    /**
-     * Allow multiple labels
-     */
-    readonly allowMultiple: boolean;
-    /**
-     * Label Options
-     */
-    readonly labelOptions: ImbricateDatabaseSchemaPropertyOptionsLabelOption[];
-};
-
-export type ImbricateDatabaseSchemaPropertyOptionsReference = {
-
-    /**
-     * Allow multiple references
-     */
-    readonly allowMultiple: boolean;
-    /**
-     * Allow references from these databases
-     *  If empty, allow references from all databases
-     */
-    readonly databases: ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase[];
-};
-
-// IMBRICATE_PROPERTY_TYPE SWITCH
-export type ImbricateDatabaseSchemaPropertyOptions<T extends IMBRICATE_PROPERTY_TYPE> =
-    T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.STRING ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.JSON ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.DATE ? {} :
-    T extends IMBRICATE_PROPERTY_TYPE.LABEL ? ImbricateDatabaseSchemaPropertyOptionsLabel :
-    T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? ImbricateDatabaseSchemaPropertyOptionsReference :
-    never;
-
-export type ImbricateDatabaseSchemaPropertyForCreation<T extends IMBRICATE_PROPERTY_TYPE> = {
-
-    readonly propertyName: string;
-    readonly propertyType: T;
-    readonly propertyOptions: ImbricateDatabaseSchemaPropertyOptions<T>;
-
-    readonly isPrimaryKey?: boolean;
-};
-
-export type ImbricateDatabaseSchema = {
-
-    readonly properties: Array<ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>>
-};
-
-export type ImbricateDatabaseSchemaForCreation = {
-
-    readonly properties: Array<ImbricateDatabaseSchemaPropertyForCreation<IMBRICATE_PROPERTY_TYPE>>
-};
-
-/**
- * Validate a schema property
- * 
- * @param property property to validate
- * 
- * @returns a string error message if validation failed
- *      null if validation passed
- */
-export const validateImbricateSchemaProperty = (
-    property: ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>,
-): string | null => {
-
-    if (typeof property.propertyIdentifier !== "string") {
-        return "Property identifier must be a string";
-    }
-    if (typeof property.propertyName !== "string") {
-        return "Property name must be a string";
-    }
-    if (!Object.values(IMBRICATE_PROPERTY_TYPE).includes(property.propertyType)) {
-        return "Property type must be a valid type";
-    }
-
-    switch (property.propertyType) {
-
-        case IMBRICATE_PROPERTY_TYPE.REFERENCE: {
-            if (typeof property.propertyOptions !== "object") {
-                return "Property options must be an object";
-            }
-            if (typeof (property.propertyOptions as any).allowMultiple !== "boolean") {
-                return "Property options allowMultiple must be a boolean";
-            }
-            if (!Array.isArray((property.propertyOptions as any).databases)) {
-                return "Property options databases must be an array";
-            }
-            for (const database of (property.propertyOptions as any).databases) {
-                if (typeof database.originUniqueIdentifier !== "string") {
-                    return "Database originUniqueIdentifier must be a string";
-                }
-                if (typeof database.databaseUniqueIdentifier !== "string") {
-                    return "Database databaseUniqueIdentifier must be a string";
-                }
-            }
-            break;
-        }
-    }
-
-    return null;
-};
-
-/**
- * Validate a schema
- * 
- * @param schema database schema to validate
- * 
- * @returns a string error message if validation failed
- *    null if validation passed
- */
-export const validateImbricateSchema = (
-    schema: ImbricateDatabaseSchema,
-): string | null => {
-
-    if (!Array.isArray(schema.properties)) {
-        return "Properties must be an array";
-    }
-
-    const propertyNames: Set<string> = new Set();
-    for (const property of schema.properties) {
-
-        const propertyValidationResult: string | null = validateImbricateSchemaProperty(property);
-        if (typeof propertyValidationResult === "string") {
-            return `Invalid property ${property.propertyName}, ${propertyValidationResult}`;
-        }
-
-        if (propertyNames.has(property.propertyName)) {
-            return `Duplicated property name ${property.propertyName}`;
-        }
-        propertyNames.add(property.propertyName);
-    }
-
-    return null;
-};

package/src/database/validate.ts

@@ -1,77 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Database
- * @description Validate
- */
-
-import { ImbricateDocumentQuery } from "./definition";
-
-/**
- * Validate imbricate document query
- * 
- * @param query query to validate
- * 
- * @returns a string error message if validation failed
- *        null if validation passed
- */
-export const validateImbricateDocumentQuery = (query: ImbricateDocumentQuery): string | null => {
-
-    if (typeof query !== "object") {
-        return "Query must be an object";
-    }
-
-    if (query.limit !== undefined && typeof query.limit !== "number" && query.limit <= 0) {
-        return "Limit must be a number greater than 0 or undefined";
-    }
-    if (query.skip !== undefined && typeof query.skip !== "number" && query.skip < 0) {
-        return "Skip must be a number greater than or equal to 0 or undefined";
-    }
-
-    if (query.propertyFilters !== undefined) {
-        if (!Array.isArray(query.propertyFilters)) {
-            return "Property filters must be an array";
-        }
-
-        for (const filter of query.propertyFilters) {
-
-            if (typeof filter.propertyIdentifier !== "string") {
-                return "Property identifier must be a string";
-            }
-
-            if (!Array.isArray(filter.conditions)) {
-                return "Conditions must be an array";
-            }
-
-            for (const condition of filter.conditions) {
-
-                if (typeof condition.target !== "string") {
-                    return "Target must be a string";
-                }
-                if (typeof condition.condition !== "string") {
-                    return "Condition must be a string";
-                }
-            }
-        }
-    }
-
-    if (query.annotationFilters !== undefined) {
-        if (!Array.isArray(query.annotationFilters)) {
-            return "Annotation filters must be an array";
-        }
-
-        for (const filter of query.annotationFilters) {
-
-            if (typeof filter.namespace !== "string") {
-                return "Namespace must be a string";
-            }
-            if (typeof filter.identifier !== "string") {
-                return "Identifier must be a string";
-            }
-            if (typeof filter.condition !== "string") {
-                return "Condition must be a string";
-            }
-        }
-    }
-
-    return null;
-};

package/src/document/property/default-value.ts

@@ -1,26 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Default Value
- */
-
-import { DocumentPropertyValueObject, IMBRICATE_PROPERTY_TYPE } from "../property";
-
-// IMBRICATE_PROPERTY_TYPE SWITCH
-export const getImbricateDefaultValueOfProperty = (type: IMBRICATE_PROPERTY_TYPE): DocumentPropertyValueObject<IMBRICATE_PROPERTY_TYPE> => {
-
-    switch (type) {
-
-        case IMBRICATE_PROPERTY_TYPE.BOOLEAN: return false;
-        case IMBRICATE_PROPERTY_TYPE.STRING: return "";
-        case IMBRICATE_PROPERTY_TYPE.NUMBER: return 0;
-        case IMBRICATE_PROPERTY_TYPE.MARKDOWN: return "";
-        case IMBRICATE_PROPERTY_TYPE.JSON: return "";
-        case IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: return "";
-        case IMBRICATE_PROPERTY_TYPE.DATE: return new Date().toISOString();
-        case IMBRICATE_PROPERTY_TYPE.LABEL: return [];
-        case IMBRICATE_PROPERTY_TYPE.REFERENCE: return [];
-    }
-
-    return null as any;
-};

package/src/document/property/primary.ts

@@ -1,29 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Primary
- */
-
-import { ImbricateDatabaseSchema } from "../../database/schema";
-import { DocumentProperties, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
-
-export const findPrimaryProperty = (
-    schema: ImbricateDatabaseSchema,
-    properties: DocumentProperties,
-): DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> | null => {
-
-    for (const property of schema.properties) {
-
-        if (property.isPrimaryKey) {
-
-            const value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> | undefined =
-                properties[property.propertyIdentifier];
-
-            if (value) {
-                return value;
-            }
-        }
-    }
-
-    return null;
-};

package/src/document/property/triage-base.ts

@@ -1,138 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Triage Base
- */
-
-import { DocumentProperties, DocumentPropertyKey, IMBRICATE_PROPERTY_TYPE } from "../property";
-import { DocumentPropertyTriageFunction } from "./definition";
-
-// IMBRICATE_PROPERTY_TYPE SWITCH
-export class ImbricateDocumentPropertyTriageBase<Result> {
-
-    private readonly _triageFunctionsByKey: Map<string, DocumentPropertyTriageFunction<any, Result>>;
-    private readonly _triageFunctionsByType: Map<IMBRICATE_PROPERTY_TYPE, DocumentPropertyTriageFunction<any, Result>>;
-
-    protected constructor() {
-
-        this._triageFunctionsByKey = new Map();
-        this._triageFunctionsByType = new Map();
-    }
-
-    /**
-     * Set triage function for property key,
-     *  This action will override document value based triage functions
-     * 
-     * @param propertyKey property key
-     * @param triageFunction triage function
-     * @returns triage manager
-     */
-    public forPropertyKey<T extends IMBRICATE_PROPERTY_TYPE>(
-        propertyKey: DocumentPropertyKey,
-        triageFunction: DocumentPropertyTriageFunction<T, Result>,
-    ): this {
-
-        this._triageFunctionsByKey.set(propertyKey, triageFunction);
-        return this;
-    }
-
-    public forBoolean(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.BOOLEAN, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.BOOLEAN, triageFunction);
-        return this;
-    }
-
-    public forString(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.STRING, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.STRING, triageFunction);
-        return this;
-    }
-
-    public forNumber(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.NUMBER, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.NUMBER, triageFunction);
-        return this;
-    }
-
-    public forMarkdown(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.MARKDOWN, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.MARKDOWN, triageFunction);
-        return this;
-    }
-
-    public forJson(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.JSON, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.JSON, triageFunction);
-        return this;
-    }
-
-    public forImbriscript(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, triageFunction);
-        return this;
-    }
-
-    public forDate(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.DATE, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.DATE, triageFunction);
-        return this;
-    }
-
-    public forLabel(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.LABEL, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.LABEL, triageFunction);
-        return this;
-    }
-
-    public forReference(
-        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.REFERENCE, Result>,
-    ): this {
-
-        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.REFERENCE, triageFunction);
-        return this;
-    }
-
-    protected _collect(properties: DocumentProperties): Map<DocumentPropertyKey, Result> {
-
-        const keys: DocumentPropertyKey[] = Object.keys(properties);
-        const result: Map<DocumentPropertyKey, Result> = new Map();
-        for (const key of keys) {
-
-            const property = properties[key];
-            const triageFunction = this._triageFunctionsByKey.get(key);
-
-            if (typeof triageFunction === "function") {
-
-                const value: Result = triageFunction(key, property);
-                result.set(key, value);
-                continue;
-            }
-
-            const typeFunction = this._triageFunctionsByType.get(property.type);
-            if (typeof typeFunction === "function") {
-
-                const value: Result = typeFunction(key, property);
-                result.set(key, value);
-                continue;
-            }
-        }
-
-        return result;
-    }
-}

package/src/document/property/triage-manager.ts

@@ -1,68 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Triage Manager
- */
-
-import { DocumentProperties, DocumentPropertyKey } from "../property";
-import { ImbricateDocumentPropertyTriageBase } from "./triage-base";
-
-export class ImbricateDocumentPropertyTriageManager<Result> extends ImbricateDocumentPropertyTriageBase<Result> {
-
-    public static create<Result>(
-        properties: DocumentProperties,
-    ): ImbricateDocumentPropertyTriageManager<Result> {
-
-        return new ImbricateDocumentPropertyTriageManager<Result>(properties);
-    }
-
-    private readonly _properties: DocumentProperties;
-
-    private constructor(
-        properties: DocumentProperties,
-    ) {
-
-        super();
-        this._properties = properties;
-    }
-
-    /**
-     * Collect the result as array
-     * 
-     * @returns collected result as array
-     */
-    public collectAsArray(): Result[] {
-
-        const result: Map<DocumentPropertyKey, Result> = super._collect(this._properties);
-        return Array.from(result.values());
-    }
-
-    /**
-     * Collect the result as map
-     * 
-     * @returns collected result as map
-     */
-    public collectAsMap(): Map<DocumentPropertyKey, Result> {
-
-        return super._collect(this._properties);
-    }
-
-    /**
-     * Collect the result as object
-     * 
-     * @returns collected result as object
-     */
-    public collectAsObject(): Record<DocumentPropertyKey, Result> {
-
-        const result: Map<DocumentPropertyKey, Result> = super._collect(this._properties);
-        const keys: DocumentPropertyKey[] = Array.from(result.keys());
-
-        const object: Record<DocumentPropertyKey, Result> = {} as Record<DocumentPropertyKey, Result>;
-        for (const key of keys) {
-
-            object[key] = result.get(key) as Result;
-        }
-
-        return object;
-    }
-}

package/src/document/property/triage.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Triage
- */
-
-import { DocumentProperties } from "../property";
-import { ImbricateDocumentPropertyTriageManager } from "./triage-manager";
-
-export const triageImbricateDocumentProperties = <Result>(
-    properties: DocumentProperties,
-): ImbricateDocumentPropertyTriageManager<Result> => {
-
-    return ImbricateDocumentPropertyTriageManager.create<Result>(properties);
-};