macroforge_ts 0.1.30

TypeScript macro expansion engine - write compile-time macros in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

"use strict";
/**
 * Serde runtime helpers for macroforge Serialize/Deserialize macros.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.PendingRef = exports.DeserializeContext = exports.SerializeContext = void 0;

// ============================================================================
// Serialization Context
// ============================================================================

var SerializeContext;
(function (SerializeContext) {
    function create() {
        const ids = new WeakMap();
        let nextId = 0;
        return {
            getId: (obj) => ids.get(obj),
            register: (obj) => {
                const id = nextId++;
                ids.set(obj, id);
                return id;
            },
        };
    }
    SerializeContext.create = create;
})(SerializeContext || (exports.SerializeContext = SerializeContext = {}));

// ============================================================================
// Deserialization Context
// ============================================================================

var DeserializeContext;
(function (DeserializeContext) {
    function create() {
        const registry = new Map();
        const patches = [];
        const toFreeze = [];
        return {
            register: (id, instance) => {
                registry.set(id, instance);
            },
            getOrDefer: (refId) => {
                if (registry.has(refId)) {
                    return registry.get(refId);
                }
                return PendingRef.create(refId);
            },
            assignOrDefer: (target, prop, value) => {
                if (PendingRef.is(value)) {
                    target[prop] = null;
                    patches.push({ target, prop, refId: value.id });
                }
                else {
                    target[prop] = value;
                }
            },
            addPatch: (target, prop, refId) => {
                patches.push({ target, prop, refId });
            },
            trackForFreeze: (obj) => {
                toFreeze.push(obj);
            },
            applyPatches: () => {
                for (const { target, prop, refId } of patches) {
                    if (!registry.has(refId)) {
                        throw new Error(`Unresolved reference: __ref ${refId}`);
                    }
                    target[prop] = registry.get(refId);
                }
            },
            freezeAll: () => {
                for (const obj of toFreeze) {
                    Object.freeze(obj);
                }
            },
        };
    }
    DeserializeContext.create = create;
})(DeserializeContext || (exports.DeserializeContext = DeserializeContext = {}));

// ============================================================================
// Pending Reference Marker
// ============================================================================

var PendingRef;
(function (PendingRef) {
    function create(id) {
        return { __pendingRef: true, id };
    }
    PendingRef.create = create;
    function is(value) {
        return (value !== null &&
            typeof value === "object" &&
            value.__pendingRef === true &&
            typeof value.id === "number");
    }
    PendingRef.is = is;
})(PendingRef || (exports.PendingRef = PendingRef = {}));