@bikky/replication 1.0.1

package/Constants/SerialisationTypes.js

@@ -0,0 +1,160 @@
+export function getClassOfObject(obj) {
+    return obj.__proto__.constructor;
+}
+export function generateDataName(name) {
+    //I'd love to put spaces in front of each capital letter, but it's really hard to do
+    // that with a matching type.
+    // return name[0].toUpperCase() + name.substring(1).replace(/(?!\b)([A-Z])/gm, " $1");
+    return (name[0].toUpperCase() + name.substring(1)).replace(/\./g, "");
+}
+export function describeObject(type) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (type === null)
+        return "null";
+    if (typeof type === "undefined")
+        return "undefined";
+    if (typeof type === "string")
+        return type;
+    if (typeof type === "function" && !type.prototype)
+        return `Function(${type.name})`;
+    if (type.prototype) {
+        return (_d = (_b = (_a = type.prototype.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = type.constructor) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : type.name;
+    }
+    if (typeof type !== "object") {
+        return typeof type;
+    }
+    if (((_e = type.constructor) === null || _e === void 0 ? void 0 : _e.name) == "ReplicableClass")
+        return `{ ReplicableClass: ${describeObject(type.classConstructor)} }`;
+    if (type.__proto__ && type.__proto__ !== Object.prototype) {
+        return (_j = (_g = (_f = type.__proto__.constructor) === null || _f === void 0 ? void 0 : _f.name) !== null && _g !== void 0 ? _g : (_h = type.__proto__) === null || _h === void 0 ? void 0 : _h.name) !== null && _j !== void 0 ? _j : type.name;
+    }
+    //Kindof a bad hack, but we're avoiding a circular reference.
+    if ("name" in type)
+        return `{ Object ${type.name} }`;
+    if ("debugName" in type)
+        return `${type.debugName}`;
+    if (Array.isArray(type))
+        return `[${type.map(describeObject).join(", ")}]`;
+    return JSON.stringify(type, (key, value) => {
+        //Key is always "" for the parent object
+        if (key == "")
+            return value;
+        if (isPrimitiveValue(value))
+            return value;
+        return describeObject(value);
+    });
+}
+export function describeObjects(types, brackets = true) {
+    if (types.length == 1)
+        return describeObject(types[0]);
+    if (brackets)
+        return `(${describeObjects(types, false)})`;
+    return types.map((e) => describeObject(e)).join(" | ");
+}
+//Stores the type on the class'/object's prototype.
+export const TypeSymbol = Symbol("ReplicableType");
+//Stores the loaded data on the object.
+export const DataSymbol = Symbol("ReplicableData");
+export var ClassCategory;
+(function (ClassCategory) {
+    //First four are mutually exclusive
+    ClassCategory[ClassCategory["Primitive"] = 0] = "Primitive";
+    ClassCategory[ClassCategory["Struct"] = 1] = "Struct";
+    // Inlined for properties it means that the property should be inlined when serialising
+    //  rather than sending a reference.
+    ClassCategory[ClassCategory["Inlined"] = 2] = "Inlined";
+    ClassCategory[ClassCategory["Pointer"] = 4] = "Pointer";
+    // For classes it means that the class is treated like a struct at runtime (no pointer) but treated as a
+    //  class when serialising (passed by reference).
+    // Opposite of inlined.
+    ClassCategory[ClassCategory["Custom"] = 8] = "Custom";
+})(ClassCategory || (ClassCategory = {}));
+(function (ClassCategory) {
+    function isType(type, category) {
+        return (type & category) == category;
+    }
+    ClassCategory.isType = isType;
+    function isTypeOr(type, ...categories) {
+        return categories.some((c) => isType(type, c));
+    }
+    ClassCategory.isTypeOr = isTypeOr;
+    function isTypeAnd(type, ...categories) {
+        return categories.every((c) => isType(type, c));
+    }
+    ClassCategory.isTypeAnd = isTypeAnd;
+})(ClassCategory || (ClassCategory = {}));
+export var PropertyTypes;
+(function (PropertyTypes) {
+    PropertyTypes[PropertyTypes["AsIs"] = 0] = "AsIs";
+    PropertyTypes[PropertyTypes["Definition"] = 1] = "Definition";
+    PropertyTypes[PropertyTypes["Serialised"] = 2] = "Serialised";
+    PropertyTypes[PropertyTypes["ForceInline"] = 3] = "ForceInline";
+    //The rest are all modifiers.
+    PropertyTypes[PropertyTypes["Expression"] = 4] = "Expression";
+    PropertyTypes[PropertyTypes["Array"] = 8] = "Array";
+    PropertyTypes[PropertyTypes["Array2"] = 16] = "Array2";
+    PropertyTypes[PropertyTypes["Dictionary"] = 32] = "Dictionary";
+    PropertyTypes[PropertyTypes["Map"] = 64] = "Map";
+    PropertyTypes[PropertyTypes["Solo"] = 128] = "Solo";
+})(PropertyTypes || (PropertyTypes = {}));
+(function (PropertyTypes) {
+    function isType(type, category) {
+        return (type & category) == category;
+    }
+    PropertyTypes.isType = isType;
+    function isTypeOr(type, ...categories) {
+        return categories.some((c) => isType(type, c));
+    }
+    PropertyTypes.isTypeOr = isTypeOr;
+    function isTypeAnd(type, ...categories) {
+        return categories.every((c) => isType(type, c));
+    }
+    PropertyTypes.isTypeAnd = isTypeAnd;
+    function ModOnly(type) {
+        return type & ~0b00000111;
+    }
+    PropertyTypes.ModOnly = ModOnly;
+    function allAreType(category, ...types) {
+        return types.every((c) => isType(c, category));
+    }
+    PropertyTypes.allAreType = allAreType;
+})(PropertyTypes || (PropertyTypes = {}));
+export function isPrimitiveType(type) {
+    return type === String || type === Number || type === Boolean || type === null || type === undefined;
+}
+export function primitiveTypeName(type) {
+    return type === null ? "null" : typeof type === "undefined" ? "undefined" : type.name.toLowerCase();
+}
+export function GetTypeName(type) {
+    return isPrimitiveType(type) ? primitiveTypeName(type) : type.opts.typescriptTypeName;
+}
+export function isPrimitiveValue(object) {
+    return (typeof object !== "object" && typeof object !== "function") || object === null;
+}
+export function getPrimitiveClass(object) {
+    switch (typeof object) {
+        case "string": return String;
+        case "number": return Number;
+        case "boolean": return Boolean;
+        case "undefined": return undefined;
+        case "object": {
+            if (object === null) {
+                return null;
+            }
+        }
+    }
+    throw new Error(`Object ${describeObject(object)} is not a known primitive type!`);
+}
+export function ValueIsPrimitiveType(type, value) {
+    if (type === undefined)
+        return typeof value === "undefined";
+    if (type === null)
+        return value === null;
+    if (type === String)
+        return typeof value === "string";
+    if (type === Number)
+        return typeof value === "number";
+    if (type === Boolean)
+        return typeof value === "boolean";
+    return false;
+}

package/Constants/SourceMaps.d.ts

@@ -0,0 +1,10 @@
+import { Versions } from "./Versions.js";
+export interface SourceMap {
+    SourceFile: string;
+    Version: Versions | string;
+}
+export type ImportDetails = Omit<SourceMap, "SourceFile"> & Partial<SourceMap>;
+export declare namespace SourceMap {
+    function get<O extends object = any>(object: O): SourceMap | undefined;
+    function add<O extends object = any>(object: O, data: SourceMap): void;
+}

package/Constants/SourceMaps.js

@@ -0,0 +1,12 @@
+let cache = new WeakMap();
+export var SourceMap;
+(function (SourceMap) {
+    function get(object) {
+        return cache.get(object);
+    }
+    SourceMap.get = get;
+    function add(object, data) {
+        cache.set(object, data);
+    }
+    SourceMap.add = add;
+})(SourceMap || (SourceMap = {}));

package/Constants/TraversalStep.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class TraversalStep<T = any> {
+    abstract get(): T;
+    abstract set(value: T): void;
+    abstract call<F extends T extends (...args: any[]) => any ? T : never>(...args: Parameters<F>): ReturnType<F>;
+}

package/Constants/TraversalStep.js

@@ -0,0 +1,2 @@
+export class TraversalStep {
+}

package/Constants/Versions.d.ts

@@ -0,0 +1,15 @@
+export declare enum Versions {
+    v1_0_0 = "1.0.0",
+    MAX = "1.0.0"
+}
+export declare function MinVersion(...versions: (Versions | string)[]): Versions;
+/**
+ * This function is only for testing!
+ */
+export declare function ClearVersions(): void;
+export declare function AddVersion(version: string | Versions, parent: string | Versions): void;
+export declare function GetVersionIndex(version: string): number;
+export declare function GetVersionIndex<T = typeof Versions>(version: T[keyof T]): number;
+export declare function GetAllVersions(): string[];
+export declare function GetAllVersionsAfter(version: string): string[];
+export declare function GetVersionController(): any;

package/Constants/Versions.js

@@ -0,0 +1,63 @@
+import { TreeMap } from "@bikky/smart-collections";
+export var Versions;
+(function (Versions) {
+    Versions["v1_0_0"] = "1.0.0";
+    Versions["MAX"] = "1.0.0";
+})(Versions || (Versions = {}));
+const VersionApplicationOrder = [Versions.v1_0_0];
+const VersionHierarchy = new TreeMap(Versions.v1_0_0);
+Object.defineProperty(Versions, "MAX", {
+    get() {
+        return VersionApplicationOrder[VersionApplicationOrder.length - 1];
+    }
+});
+export function MinVersion(...versions) {
+    let min = [];
+    let minStr = "";
+    for (let version of versions) {
+        let nums = version.split(/\./g).map((e) => parseInt(e));
+        for (let i = 0; i < nums.length; i++) {
+            if (typeof min[i] === "undefined") {
+                min = nums;
+                minStr = version;
+                break;
+            }
+            if (nums[i] < min[i]) {
+                min = nums;
+                minStr = version;
+                break;
+            }
+        }
+    }
+    return minStr;
+}
+/**
+ * This function is only for testing!
+ */
+export function ClearVersions() {
+    if (typeof TestingMode === "boolean" && TestingMode) {
+        VersionHierarchy.clear();
+        VersionApplicationOrder.length = 0;
+        VersionApplicationOrder[0] = VersionHierarchy.getBase();
+    }
+    else {
+        throw new Error("This function is only for testing!");
+    }
+}
+export function AddVersion(version, parent) {
+    VersionApplicationOrder.push(version.toString());
+    VersionHierarchy.addChild(version, parent);
+}
+export function GetVersionIndex(version) {
+    return VersionApplicationOrder.indexOf(version);
+}
+export function GetAllVersions() {
+    return [...VersionApplicationOrder];
+}
+export function GetAllVersionsAfter(version) {
+    let index = GetVersionIndex(version);
+    return VersionApplicationOrder.slice(index + 1);
+}
+export function GetVersionController() {
+    return VersionHierarchy;
+}

package/Expressions/Compiler/BuiltinGrammar.d.ts

@@ -0,0 +1,234 @@
+import { EAST_Token, ExpressionGrammar } from "./ExpressionGrammar.js";
+import { Token } from "./Tokenizer.js";
+export declare namespace ExpressionAST {
+    import Node = ExpressionGrammar.EAST_Complex_Node;
+    import NodeType = ExpressionGrammar.NodeType;
+    type ControlFlowLoopNodes = BreakNode | ContinueNode;
+    export function IsLoopNode(node: Node): node is ForNode | WhileNode;
+    export function IsControlFlowNode(node: Node): node is ContinueNode | BreakNode;
+    export interface ContinueNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.CONTINUE;
+        values: undefined;
+    }
+    export function IsContinueNode(node: Node): node is ContinueNode;
+    export interface BreakNode extends Node {
+        type: NodeType.BREAK;
+        values: undefined;
+    }
+    export function IsBreakNode(node: Node): node is BreakNode;
+    export interface WhileNode extends Node {
+        type: NodeType.WHILE_LOOP;
+        values: {
+            test: ExpressionNode;
+            body: BlockNode<ControlFlowLoopNodes> | StatementNode;
+        };
+    }
+    export function IsWhileNode(node: Node): node is WhileNode;
+    export interface ForNode extends Node {
+        type: NodeType.FOR_LOOP;
+        values: {
+            initialiser: ExpressionNode;
+            test: ExpressionNode;
+            incrementer: ExpressionNode;
+            body: BlockNode<ControlFlowLoopNodes> | StatementNode;
+        };
+    }
+    export function IsForNode(node: Node): node is ForNode;
+    export interface StatementNode extends Node {
+        type: NodeType.STATEMENT;
+        values: {
+            expression: ExpressionNode["values"]["expression"];
+        };
+    }
+    export function IsStatementNode(node: Node): node is StatementNode;
+    export interface ExpressionNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.EXPRESSION;
+        values: {
+            expression: ArrayAccessSequenceNode | FunctionCallNode | MemberAccessNode | BinaryExpressionNode | ParenthetisedExpressionNode | UnaryExpressionNode | ForceCastNode | CastNode | AssignmentNode | EAST_Token | LiteralNode;
+        };
+    }
+    export function IsExpressionNode(node: Node): node is ExpressionNode;
+    export interface MemberAccessNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.MEMBER_ACCESS;
+        values: {
+            context: ParenthetisedExpressionNode | EAST_Token | ForceCastNode | CastNode | ArrayAccessSequenceNode | FunctionCallNode;
+            memberName: MemberAccessNode | CastNode | EAST_Token;
+        };
+    }
+    export function IsMemberAccessNode(node: Node | Token): node is MemberAccessNode;
+    export interface ArrayAccessorNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.ARRAY_ACCESSOR;
+        values: {
+            index: LiteralNode | ExpressionNode;
+        };
+    }
+    export function IsArrayAccessorNode(node: Node): node is ArrayAccessorNode;
+    export interface ArrayAccessSequenceNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.ARRAY_ACCESS_SEQUENCE;
+        values: {
+            identifier: EAST_Token | ExpressionNode;
+            accessor: ArrayAccessorNode[];
+        };
+    }
+    export function IsArrayAccessSequenceNode(node: Node): node is ArrayAccessSequenceNode;
+    export interface ParenthetisedExpressionNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.PARENTHETISED_EXPRESSION;
+        values: ExpressionNode["values"];
+    }
+    export function IsParenthetisedExpressionNode(node: Node): node is ParenthetisedExpressionNode;
+    export interface BinaryExpressionNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.BINARY_EXPRESSION;
+        values: {
+            lhs: ArrayAccessSequenceNode | FunctionCallNode | ParenthetisedExpressionNode | UnaryExpressionNode | LiteralNode | EAST_Token;
+            operator: EAST_Token;
+            rhs: ExpressionNode;
+        };
+    }
+    export function IsBinaryExpressionNode(node: Node): node is BinaryExpressionNode;
+    export interface UnaryExpressionNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.UNARY_EXPRESSION;
+        values: {
+            operator: EAST_Token;
+            value: ExpressionNode;
+        };
+    }
+    export function IsUnaryExpressionNode(node: Node): node is UnaryExpressionNode;
+    export interface LiteralNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.LITERAL;
+        values: {
+            value: EAST_Token;
+        };
+    }
+    export function IsLiteralNode(node: Node): node is LiteralNode;
+    export interface AssignmentNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.ASSIGNMENT;
+        values: {
+            lhs: EAST_Token;
+            rhs: ExpressionNode;
+        };
+    }
+    export function IsAssignmentNode(node: Node): node is AssignmentNode;
+    export interface StructNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.STRUCT;
+        values: {
+            name: EAST_Token;
+            members: PropertySignatureNode[];
+        };
+    }
+    export function IsStructNode(node: Node): node is StructNode;
+    export function IsIdentifierDeclarationNode(node: Node): node is PropertySignatureNode | DeclarationNode;
+    export interface DeclarationTypeQualifierListNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.DECLARATION_TYPE_QUALIFIER_LIST;
+        values: {
+            qualifiers: EAST_Token[];
+        };
+    }
+    export function IsDeclarationTypeQualifierListNode(node: Node): node is DeclarationEntryNode;
+    export interface DeclarationTypeNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.DECLARATION_TYPE;
+        values: DeclarationTypeQualifierListNode["values"] & {
+            type: EAST_Token;
+        };
+    }
+    export function IsDeclarationTypeNode(node: Node): node is DeclarationTypeNode;
+    export interface PropertySignatureNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.PROPERTY_SIGNATURE;
+        values: DeclarationTypeNode["values"] & {
+            identifier: EAST_Token;
+        };
+    }
+    export function IsPropertySignatureNode(node: Node): node is PropertySignatureNode;
+    export interface DeclarationEntryNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.DECLARATION_ENTRY;
+        values: {
+            name: EAST_Token;
+            initialiser?: ExpressionNode;
+        };
+    }
+    export function IsDeclarationEntryNode(node: Node): node is DeclarationEntryNode;
+    export interface DeclarationNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.DECLARATION;
+        values: DeclarationTypeNode["values"] & {
+            declarations: DeclarationEntryNode[];
+        };
+    }
+    export function IsDeclarationNode(node: Node): node is DeclarationNode;
+    export interface FileNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.FILE;
+        text: string;
+        sourceLocation: string;
+        version: string;
+        values: {
+            lines: (CommentNode | PreprocessorCommandNode | FunctionDeclarationNode | DeclarationNode | ExpressionNode)[];
+        };
+    }
+    export function IsFileNode(node: Node): node is FileNode;
+    export interface BlockNode<Extensions extends ExpressionGrammar.EAST_Complex_Node | never> extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.BLOCK;
+        values: {
+            lines: (Extensions | CommentNode | DeclarationNode | StatementNode)[];
+        };
+    }
+    export function IsBlockNode(node: Node): node is BlockNode<ExpressionGrammar.EAST_Complex_Node>;
+    export interface ReturnNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.RETURN;
+        values: ExpressionNode["values"];
+    }
+    export function IsReturnNode(node: Node): node is ReturnNode;
+    export interface CommentNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.COMMENT;
+        values: {
+            comment: EAST_Token[];
+        };
+    }
+    export function IsCommentNode(node: Node): node is CommentNode;
+    export interface PreprocessorCommandNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.PREPROCESSOR_COMMAND;
+        values: {
+            command: EAST_Token;
+        };
+    }
+    export function IsPreprocessorCommandNode(node: Node): node is PreprocessorCommandNode;
+    export interface FunctionParameterNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.FUNCTION_PARAMETER;
+        values: DeclarationTypeNode["values"] & {
+            identifier: EAST_Token;
+        };
+    }
+    export function IsFunctionParameterNode(node: Node): node is FunctionParameterNode;
+    export interface FunctionDeclarationNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.FUNCTION_DECLARATION;
+        values: {
+            returnType: EAST_Token;
+            name: EAST_Token;
+            parameters: FunctionParameterNode[];
+            body: BlockNode<ReturnNode>;
+        };
+    }
+    export function IsFunctionDeclarationNode(node: Node): node is FunctionDeclarationNode;
+    export interface FunctionCallNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.FUNCTION_CALL;
+        values: {
+            name: EAST_Token | ExpressionNode;
+            arguments: ExpressionNode[];
+        };
+    }
+    export function IsFunctionCallNode(node: Node): node is FunctionCallNode;
+    export interface CastNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.CAST;
+        values: {
+            expression: ArrayAccessSequenceNode | FunctionCallNode | ParenthetisedExpressionNode | EAST_Token | LiteralNode;
+            castType: EAST_Token;
+        };
+    }
+    export function IsCastNode(node: Node): node is CastNode;
+    export interface ForceCastNode extends ExpressionGrammar.EAST_Complex_Node {
+        type: NodeType.FORCE_CAST;
+        values: {
+            expression: ArrayAccessSequenceNode | FunctionCallNode | ParenthetisedExpressionNode | EAST_Token | LiteralNode | MemberAccessNode;
+            castType: EAST_Token;
+        };
+    }
+    export function IsForceCastNode(node: Node): node is ForceCastNode;
+    export {};
+}