@flamework-experimental/transformer 2.0.0-alpha.0

package/out/util/functions/buildInstanceShape.js

@@ -0,0 +1,156 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInstanceShape = buildInstanceShape;
+var factory_1 = require("../factory");
+var buildGuardFromType_1 = require("./buildGuardFromType");
+var getInstanceTypeFromType_1 = require("./getInstanceTypeFromType");
+/**
+ * The instance tree a type describes, as the data `@flamework-experimental/components` checks and
+ * watches: `{ isA = { "Model" }, children = { Root = { isA = { "BasePart" } } } }` for
+ * `Model & { Root: BasePart }`.
+ *
+ * `componentChildren` names the direct children that are typed as a component. Their own trees
+ * belong to that component -- its tracker checks and watches them -- so the shape stops at their
+ * class.
+ *
+ * Nothing when the type says more than classes and children -- a union whose members declare
+ * children of their own, a member that is not an instance -- and the caller falls back to a `t`
+ * guard, which can say anything but has to read the whole tree to say it.
+ */
+function buildInstanceShape(state, node, type, componentChildren) {
+    var shape = readShape(state, node, type, false, true, componentChildren);
+    return shape === undefined ? undefined : emitShape(shape);
+}
+function readShape(state, node, type, allowOptional, descend, componentChildren) {
+    var e_1, _a, e_2, _b;
+    var _c;
+    var checker = state.typeChecker;
+    var members = [type];
+    var optional = false;
+    if (type.isUnion()) {
+        var _d = __read((0, buildGuardFromType_1.extractTypes)(checker, __spreadArray([], __read(type.types), false)), 2), isOptional = _d[0], types = _d[1];
+        if (isOptional && !allowOptional)
+            return undefined;
+        optional = isOptional;
+        members = types;
+    }
+    if (members.length === 0)
+        return undefined;
+    var file = state.getSourceFile(node);
+    var isA = new Array();
+    var children;
+    try {
+        for (var members_1 = __values(members), members_1_1 = members_1.next(); !members_1_1.done; members_1_1 = members_1.next()) {
+            var member = members_1_1.value;
+            if (!(0, buildGuardFromType_1.isInstanceType)(member))
+                return undefined;
+            var instanceType = (0, getInstanceTypeFromType_1.getInstanceTypeFromType)(file, member);
+            var className = (_c = instanceType.symbol) === null || _c === void 0 ? void 0 : _c.name;
+            if (className === undefined)
+                return undefined;
+            if (!isA.includes(className))
+                isA.push(className);
+            if (!descend)
+                continue;
+            var declared = new Map();
+            try {
+                for (var _e = (e_2 = void 0, __values(member.getProperties())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var property = _f.value;
+                    if (instanceType.getProperty(property.name))
+                        continue;
+                    var propertyType = checker.getTypeOfPropertyOfType(member, property.name);
+                    if (!propertyType)
+                        return undefined;
+                    var child = readShape(state, node, propertyType, true, !(componentChildren === null || componentChildren === void 0 ? void 0 : componentChildren.has(property.name)));
+                    if (child === undefined)
+                        return undefined;
+                    declared.set(property.name, child);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            if (declared.size > 0) {
+                // Which children go with which class is more than a shape says.
+                if (members.length > 1)
+                    return undefined;
+                children = declared;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (members_1_1 && !members_1_1.done && (_a = members_1.return)) _a.call(members_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { isA: isA, children: children, optional: optional };
+}
+function emitShape(shape) {
+    var e_3, _a;
+    var properties = [
+        factory_1.f.propertyAssignmentDeclaration("isA", factory_1.f.array(shape.isA.map(function (name) { return factory_1.f.string(name); }), false)),
+    ];
+    if (shape.children !== undefined) {
+        var children = new Array();
+        try {
+            for (var _b = __values(shape.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name_1 = _d[0], child = _d[1];
+                children.push(factory_1.f.propertyAssignmentDeclaration(name_1, emitShape(child)));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        properties.push(factory_1.f.propertyAssignmentDeclaration("children", factory_1.f.object(children, false)));
+    }
+    if (shape.optional) {
+        properties.push(factory_1.f.propertyAssignmentDeclaration("optional", true));
+    }
+    return factory_1.f.object(properties, false);
+}