@esportsplus/reactivity 0.37.2 → 0.38.0

package/build/compiler/index.js

@@ -1,55 +1,112 @@
 import { ts } from '@esportsplus/typescript';
-import { imports } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants.js';
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
 import scope from './bindings.js';
-function collect(checker, node, calls) {
-    if (isReactiveCallExpression(checker, node)) {
-        calls.add(node);
+function failed(sourceFile, failures) {
+    let lines = [];
+    for (let i = 0, n = failures.length; i < n; i++) {
+        let { message, node } = failures[i], position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        lines.push(`  ${sourceFile.fileName}:${position.line + 1}:${position.character + 1}  ${message}: ${node.getText(sourceFile).split('\n')[0]}`);
     }
-    node.forEachChild(child => collect(checker, child, calls));
+    return new Error(`${PACKAGE_NAME}: code that must be compiled cannot be:\n${lines.join('\n')}`);
 }
-function isReactiveCallExpression(checker, node) {
-    if (!ts.isCallExpression(node)) {
+function isConstList(node) {
+    return node !== undefined && ts.isVariableDeclarationList(node) && (node.flags & ts.NodeFlags.Const) !== 0;
+}
+function isLowered(site) {
+    let parent = site.parent;
+    while (parent && ts.isParenthesizedExpression(parent)) {
+        site = parent;
+        parent = site.parent;
+    }
+    if (!parent) {
         return false;
     }
-    let expr = node.expression;
-    if (ts.isIdentifier(expr)) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
+    if (ts.isCallExpression(parent)) {
+        return parent.expression === site;
+    }
+    if (ts.isVariableDeclaration(parent)) {
+        return parent.initializer === site && ts.isIdentifier(parent.name) && isConstList(parent.parent);
     }
-    if (ts.isPropertyAccessExpression(expr) && expr.name.text === ENTRYPOINT && ts.isIdentifier(expr.expression)) {
-        return imports.includes(checker, expr.expression, PACKAGE_NAME);
+    if (ts.isBindingElement(parent) && parent.propertyName === site) {
+        let declaration = parent;
+        while (declaration && !ts.isVariableDeclaration(declaration)) {
+            declaration = declaration.parent;
+        }
+        return declaration !== undefined && isConstList(declaration.parent);
     }
     return false;
 }
+function siteOf(identifier) {
+    let parent = identifier.parent;
+    if ((ts.isPropertyAccessExpression(parent) && parent.name === identifier) ||
+        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier)) {
+        return parent;
+    }
+    return identifier;
+}
 export default {
-    patterns: ['reactive(', 'reactive<'],
     transform: (ctx) => {
-        let checker = ctx.checker;
-        if (!checker) {
-            return {};
+        let { checker, program, sourceFile } = ctx, bindings = scope.create(checker, program, sourceFile), calls = new Set(), dependencies = new Set(), failures = [], self = sourceFile.fileName.toLowerCase();
+        for (let [identifier, found] of bindings.origins) {
+            let entry = scope.holds(bindings, found);
+            if (!entry && scope.kind(bindings, found) === null) {
+                continue;
+            }
+            for (let file of [...found.through, found.declaration.path]) {
+                if (file.toLowerCase() !== self) {
+                    dependencies.add(file);
+                }
+            }
+            if (!entry) {
+                continue;
+            }
+            let site = siteOf(identifier), parent = site.parent;
+            while (parent && ts.isParenthesizedExpression(parent)) {
+                parent = parent.parent;
+            }
+            if (parent && ts.isCallExpression(parent) && scope.unwrap(parent.expression) === site) {
+                calls.add(parent);
+            }
+            else if (!isLowered(site)) {
+                failures.push({
+                    message: `${ENTRYPOINT} is compiled away, so it can only be called (or aliased with const); it cannot be used as a value`,
+                    node: site
+                });
+            }
         }
-        let bindings = scope.create(checker), candidates = new Set(), intents = {
+        let isReactiveCall = (node) => calls.has(node), intents = {
             imports: [],
             prepend: [],
             replacements: []
-        }, sourceFile = ctx.sourceFile;
-        collect(checker, sourceFile, candidates);
-        if (candidates.size === 0) {
-            return {};
-        }
-        let isReactiveCall = (node) => candidates.has(node);
-        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
-        intents.replacements.push(...replacements);
+        };
+        let lowered = primitives(sourceFile, bindings, isReactiveCall);
+        failures.push(...lowered.failures);
+        intents.replacements.push(...lowered.replacements);
         let objects = object(sourceFile, bindings, isReactiveCall);
         intents.prepend.push(...objects.prepend);
         intents.replacements.push(...objects.replacements);
-        intents.replacements.push(...array(sourceFile, bindings, isReactiveCall));
+        let arrays = array(sourceFile, bindings, isReactiveCall);
+        failures.push(...arrays.failures);
+        intents.replacements.push(...arrays.replacements);
+        for (let i = 0, n = arrays.reactive.length; i < n; i++) {
+            let root = arrays.reactive[i];
+            while (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root) || ts.isParenthesizedExpression(root)) {
+                root = root.expression;
+            }
+            let found = ts.isIdentifier(root) ? scope.origin(bindings, root) : null;
+            if (found && found.declaration.path.toLowerCase() !== self) {
+                dependencies.add(found.declaration.path);
+            }
+        }
+        if (failures.length > 0) {
+            throw failed(sourceFile, failures);
+        }
         let transformed = new Set(intents.replacements.map(r => r.node));
-        for (let i = 0, n = calls.length; i < n; i++) {
-            let call = calls[i];
+        for (let i = 0, n = lowered.calls.length; i < n; i++) {
+            let call = lowered.calls[i];
             if (transformed.has(call) || transformed.has(call.expression)) {
                 continue;
             }
@@ -58,11 +115,16 @@ export default {
                 node: call
             });
         }
-        intents.imports.push({
-            namespace: NAMESPACE,
-            package: PACKAGE_NAME,
-            remove: [ENTRYPOINT]
-        });
-        return intents;
+        if (intents.replacements.length === 0 && intents.prepend.length === 0) {
+            return dependencies.size > 0 ? { dependencies: [...dependencies] } : {};
+        }
+        if (calls.size > 0 || lowered.replacements.length > 0 || intents.prepend.length > 0 || arrays.namespaced) {
+            intents.imports.push({
+                namespace: NAMESPACE,
+                package: PACKAGE_NAME,
+                remove: [ENTRYPOINT]
+            });
+        }
+        return { dependencies: [...dependencies], ...intents };
     }
 };

package/build/compiler/object.js

@@ -1,8 +1,8 @@
 import { ts } from '@esportsplus/typescript';
 import { code, uid } from '@esportsplus/typescript/compiler';
 import { NAMESPACE, TYPES } from './constants.js';
-import scope from './bindings.js';
-function analyzeProperty(prop, sourceFile) {
+function analyzeProperty(prop, bindings) {
+    let sourceFile = bindings.sourceFile;
     if (!ts.isPropertyAssignment(prop)) {
         return null;
     }
@@ -38,6 +38,10 @@ function analyzeProperty(prop, sourceFile) {
         }
         return { isStatic, key, type: TYPES.Array, valueText };
     }
+    let type = isStaticValue(unwrapped) ? undefined : bindings.checker.getTypeAtLocation(value);
+    if (type && (bindings.checker.isArrayType(type) || bindings.checker.isTupleType(type))) {
+        return { isStatic: false, key, type: TYPES.Array, valueText };
+    }
     return {
         isStatic: isStaticValue(value),
         key,
@@ -144,29 +148,22 @@ function visit(ctx, node) {
     if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
-            let properties = [], props = arg.properties, target = node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)
-                ? node.parent.name
-                : null, varname = target?.text ?? null;
+            let properties = [], props = arg.properties, varname = node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)
+                ? node.parent.name.text
+                : null;
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
                 if (ts.isSpreadAssignment(prop)) {
                     node.forEachChild(n => visit(ctx, n));
                     return;
                 }
-                let analyzed = analyzeProperty(prop, ctx.sourceFile);
+                let analyzed = analyzeProperty(prop, ctx.bindings);
                 if (!analyzed) {
                     node.forEachChild(n => visit(ctx, n));
                     return;
                 }
                 properties.push(analyzed);
             }
-            if (target) {
-                for (let i = 0, n = properties.length; i < n; i++) {
-                    if (properties[i].type === TYPES.Array) {
-                        scope.declarePath(ctx.bindings, target, properties[i].key);
-                    }
-                }
-            }
             ctx.calls.push({
                 classname: uid('ReactiveObject'),
                 node,
@@ -193,7 +190,7 @@ export default (sourceFile, bindings, isReactiveCall) => {
         replacements.push({
             generate: () => {
                 let args = call.properties
-                    .filter(({ isStatic, type }) => typehint || !isStatic || type === TYPES.Computed)
+                    .filter(({ isStatic, type }) => typehint || !isStatic || type !== TYPES.Signal)
                     .map(p => p.valueText)
                     .join(', ');
                 return typehint

package/build/compiler/plugins/vite.d.ts

@@ -5,7 +5,21 @@ declare const _default: ({ root }?: {
     closeWatcher: () => void;
     configResolved: (config: unknown) => void;
     enforce: 'pre';
+    handleHotUpdate: <M>(ctx: {
+        file: string;
+        modules: M[];
+        server: {
+            moduleGraph: {
+                getModulesByFile(file: string): Set<M> | undefined;
+                invalidateModule(module: M, seen: Set<M>, timestamp: number, isHmr: boolean): void;
+            };
+        };
+        timestamp: number;
+    }) => M[] | undefined;
     name: string;
+    renderChunk: (code: string, chunk: {
+        fileName: string;
+    }) => null;
     transform: (code: string, id: string) => {
         code: string;
         map: import("@esportsplus/typescript/compiler").SourceMapV3;

package/build/compiler/primitives.d.ts

@@ -1,9 +1,15 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings, IsReactiveCall } from './types.js';
+type Failure = {
+    message: string;
+    node: ts.Node;
+};
 type PrimitivesTransformResult = {
     calls: ts.CallExpression[];
+    failures: Failure[];
     replacements: ReplacementIntent[];
 };
 export default _default;
 declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): PrimitivesTransformResult;
+export type { Failure };

package/build/compiler/primitives.js

@@ -3,38 +3,33 @@ import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
 import scope from './bindings.js';
 function declare(ctx, node) {
     if (ctx.isReactiveCall(node)) {
-        let call = node;
+        let call = node, kind = scope.classify(ctx.bindings, call);
         ctx.calls.push(call);
-        if (call.arguments.length > 0) {
-            let arg = call.arguments[0], classification = TYPES.Signal;
-            if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-                classification = TYPES.Computed;
-            }
-            else {
-                let unwrapped = arg;
-                while (ts.isAsExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped) || ts.isTypeAssertion(unwrapped)) {
-                    unwrapped = unwrapped.expression;
-                }
-                if (ts.isArrayLiteralExpression(unwrapped) || ts.isObjectLiteralExpression(unwrapped)) {
-                    classification = null;
-                }
-                else if (ts.isCallExpression(unwrapped) || ts.isIdentifier(unwrapped)) {
-                    classification = null;
-                    ctx.replacements.push({
-                        generate: () => `${NAMESPACE}.reactive`,
-                        node: call.expression
-                    });
-                }
+        if (kind === null) {
+            ctx.failures.push({
+                message: 'reactive() takes one argument whose kind (value, computed, array or object) is provable; ' +
+                    'pass a literal or give the argument a concrete type (not any, unknown or a mixed union)',
+                node: call
+            });
+        }
+        else if (kind === TYPES.Signal || kind === TYPES.Computed) {
+            if (!isBound(call)) {
+                ctx.failures.push({
+                    message: `a reactive ${kind === TYPES.Signal ? 'value' : 'computed'} must initialize a variable (or be a module's ` +
+                        'default export); anywhere else its signal is never read',
+                    node: call
+                });
             }
-            if (classification !== null) {
-                let target = targetOf(call), type = classification;
-                if (target) {
-                    scope.declare(ctx.bindings, target, type);
-                }
+            ctx.replacements.push({
+                generate: () => kind === TYPES.Computed ? `${NAMESPACE}.computed` : `${NAMESPACE}.signal`,
+                node: call.expression
+            });
+        }
+        else {
+            let arg = scope.unwrap(call.arguments[0]);
+            if (!ts.isArrayLiteralExpression(arg) && !ts.isObjectLiteralExpression(arg)) {
                 ctx.replacements.push({
-                    generate: () => type === TYPES.Computed
-                        ? `${NAMESPACE}.computed`
-                        : `${NAMESPACE}.signal`,
+                    generate: () => `${NAMESPACE}.reactive`,
                     node: call.expression
                 });
             }
@@ -42,12 +37,33 @@ function declare(ctx, node) {
     }
     node.forEachChild(child => declare(ctx, child));
 }
-function isName(node, parent) {
-    if (ts.isShorthandPropertyAssignment(parent)) {
+function isBound(call) {
+    let node = call, parent = node.parent;
+    while (parent &&
+        (ts.isAsExpression(parent) || ts.isNonNullExpression(parent) || ts.isParenthesizedExpression(parent) || ts.isSatisfiesExpression(parent))) {
+        node = parent;
+        parent = node.parent;
+    }
+    if (!parent) {
         return false;
     }
-    let slots = parent;
-    return slots.name === node || slots.propertyName === node || slots.label === node;
+    if (ts.isVariableDeclaration(parent)) {
+        return parent.initializer === node && ts.isIdentifier(parent.name);
+    }
+    if (ts.isBinaryExpression(parent)) {
+        return parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.right === node && ts.isIdentifier(parent.left);
+    }
+    return ts.isExportAssignment(parent);
+}
+function isNamespace(bindings, expression) {
+    let value = scope.unwrap(expression);
+    if (ts.isAwaitExpression(value)) {
+        value = scope.unwrap(value.expression);
+    }
+    if (ts.isCallExpression(value)) {
+        return value.expression.kind === ts.SyntaxKind.ImportKeyword;
+    }
+    return ts.isIdentifier(value) && scope.origin(bindings, value)?.declaration.kind === ts.SyntaxKind.SourceFile;
 }
 function isPatternTarget(node) {
     let current = node;
@@ -67,24 +83,30 @@ function isPatternTarget(node) {
     return (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === current) ||
         ((ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === current);
 }
-function reference(ctx, node) {
+function readNode(identifier) {
+    let parent = identifier.parent;
+    if ((ts.isPropertyAccessExpression(parent) && parent.name === identifier) ||
+        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier)) {
+        return parent;
+    }
+    return identifier;
+}
+function reference(ctx, node, kind) {
     let parent = node.parent;
-    if (!parent || ts.isExportSpecifier(parent) || ts.isImportSpecifier(parent) || isName(node, parent)) {
+    if (!parent) {
         return;
     }
-    let binding = scope.resolve(ctx.bindings, node);
-    if (!binding || binding.type === TYPES.Array) {
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node && ctx.isReactiveCall(scope.unwrap(parent.right))) {
         return;
     }
-    if ((ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node && ctx.isReactiveCall(parent.right)) ||
-        (ts.isTypeOfExpression(parent) && parent.expression === node) ||
-        isPatternTarget(node)) {
+    if (isPatternTarget(node)) {
+        ctx.failures.push({ message: 'a reactive binding cannot be assigned through a destructuring pattern; assign it directly', node });
         return;
     }
-    let name = node.text;
+    let text = node.getText(ctx.bindings.sourceFile);
     if (ts.isShorthandPropertyAssignment(parent)) {
         ctx.replacements.push({
-            generate: () => `${name}: ${NAMESPACE}.read(${name})`,
+            generate: () => `${text}: ${NAMESPACE}.read(${text})`,
             node: parent
         });
         return;
@@ -107,25 +129,26 @@ function reference(ctx, node) {
     }
     if (!writeCtx) {
         ctx.replacements.push({
-            generate: () => `${NAMESPACE}.read(${name})`,
+            generate: () => `${NAMESPACE}.read(${text})`,
             node
         });
         return;
     }
-    if (binding.type === TYPES.Computed) {
+    if (kind === TYPES.Computed) {
+        ctx.failures.push({ message: 'a reactive computed is read-only', node });
         return;
     }
     if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
         let right = parent.right;
         ctx.replacements.push({
-            generate: (sf) => `${NAMESPACE}.write(${name}, ${right.getText(sf)})`,
+            generate: (sf) => `${NAMESPACE}.write(${text}, ${right.getText(sf)})`,
             node: parent
         });
     }
     else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
         let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+', right = parent.right;
         ctx.replacements.push({
-            generate: (sf) => `${NAMESPACE}.write(${name}, ${name}.value ${op} ${right.getText(sf)})`,
+            generate: (sf) => `${NAMESPACE}.write(${text}, ${text}.value ${op} ${right.getText(sf)})`,
             node: parent
         });
     }
@@ -133,54 +156,63 @@ function reference(ctx, node) {
         let unary = parent, delta = unary.operator === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
         if (ts.isExpressionStatement(unary.parent)) {
             ctx.replacements.push({
-                generate: () => `${NAMESPACE}.write(${name}, ${name}.value ${delta})`,
+                generate: () => `${NAMESPACE}.write(${text}, ${text}.value ${delta})`,
                 node: unary
             });
         }
         else if (ts.isPrefixUnaryExpression(unary)) {
             ctx.replacements.push({
-                generate: () => `(${NAMESPACE}.write(${name}, ${name}.value ${delta}), ${name}.value)`,
+                generate: () => `(${NAMESPACE}.write(${text}, ${text}.value ${delta}), ${text}.value)`,
                 node: unary
             });
         }
         else {
             let tmp = `_t${ctx.tmpCounter++}`;
             ctx.replacements.push({
-                generate: () => `((${tmp}) => (${NAMESPACE}.write(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                generate: () => `((${tmp}) => (${NAMESPACE}.write(${text}, ${tmp} ${delta}), ${tmp}))(${text}.value)`,
                 node: unary
             });
         }
     }
 }
-function rewrite(ctx, node) {
-    if (ts.isTypeNode(node)) {
-        return;
-    }
-    if (ts.isIdentifier(node)) {
-        reference(ctx, node);
-        return;
+function rewrite(ctx) {
+    let { bindings } = ctx;
+    for (let [identifier, found] of bindings.origins) {
+        let kind = scope.kind(bindings, found);
+        if (kind !== TYPES.Signal && kind !== TYPES.Computed) {
+            continue;
+        }
+        let parent = identifier.parent;
+        if (ts.isBindingElement(parent) && parent.propertyName === identifier) {
+            ctx.failures.push({ message: 'a reactive binding cannot be destructured (it would copy its signal); read it through the namespace', node: identifier });
+            continue;
+        }
+        reference(ctx, readNode(identifier), kind);
     }
-    node.forEachChild(child => rewrite(ctx, child));
+    unpacked(ctx, bindings.sourceFile);
 }
-function targetOf(call) {
-    let parent = call.parent;
-    if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
-        return parent.name;
-    }
-    if (parent && ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(parent.left)) {
-        return parent.left;
+function unpacked(ctx, node) {
+    if (ts.isBindingElement(node) && !node.propertyName && ts.isObjectBindingPattern(node.parent)) {
+        let initializer = node.parent.parent.initializer;
+        if (initializer && isNamespace(ctx.bindings, initializer)) {
+            let kind = scope.kind(ctx.bindings, scope.origin(ctx.bindings, node));
+            if (kind === TYPES.Signal || kind === TYPES.Computed) {
+                ctx.failures.push({ message: 'a reactive binding cannot be destructured (it would copy its signal); read it through the namespace', node });
+            }
+        }
     }
-    return null;
+    node.forEachChild(child => unpacked(ctx, child));
 }
 export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
         calls: [],
+        failures: [],
         isReactiveCall,
         replacements: [],
         tmpCounter: 0
     };
     declare(ctx, sourceFile);
-    rewrite(ctx, sourceFile);
-    return { calls: ctx.calls, replacements: ctx.replacements };
+    rewrite(ctx);
+    return { calls: ctx.calls, failures: ctx.failures, replacements: ctx.replacements };
 };

package/build/compiler/types.d.ts

@@ -1,10 +1,11 @@
 import type { ts } from '@esportsplus/typescript';
-import type { TYPES } from './constants.js';
+import type { Origin } from '@esportsplus/typescript/compiler';
 type Bindings = {
     checker: ts.Checker;
-    names: Set<string>;
-    paths: Map<ts.Symbol, Set<string>>;
-    symbols: Map<ts.Symbol, TYPES>;
+    entries: Set<string>;
+    origins: Map<ts.Node, Origin>;
+    program: ts.Program;
+    sourceFile: ts.SourceFile;
 };
 type IsReactiveCall = (node: ts.Node) => node is ts.CallExpression;
 export type { Bindings, IsReactiveCall };

package/build/types.d.ts

@@ -33,7 +33,7 @@ interface Link {
 declare const READONLY: unique symbol;
 type Reactive<T> = T extends (...args: never[]) => infer R ? Settled<R> & {
     readonly [READONLY]: true;
-} : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'dispose' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
+} : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, '$length' | '$set' | 'clear' | 'dispose' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K] extends (infer U)[] ? Reactive<U[]> : T[K];
 } & {
     dispose: VoidFunction;

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.28.6"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.36.1",
+    "@esportsplus/typescript": "^0.37.0",
     "@types/node": "^26.4.1",
     "vite": "^8.2.2",
     "vitest": "^5.0.0"
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.37.2",
+  "version": "0.38.0",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/pnpm-workspace.yaml

@@ -2,7 +2,7 @@ allowBuilds:
   esbuild: true
 minimumReleaseAgeExclude:
   - '@esportsplus/utilities@0.28.1 || 0.28.3 || 0.28.4 || 0.28.6'
-  - '@esportsplus/typescript@0.31.0 || 0.32.0 || 0.33.0 || 0.33.2 || 0.33.4 || 0.34.1 || 0.34.3 || 0.34.4 || 0.36.0 || 0.36.1'
+  - '@esportsplus/typescript@0.31.0 || 0.32.0 || 0.33.0 || 0.33.2 || 0.33.4 || 0.34.1 || 0.34.3 || 0.34.4 || 0.36.0 || 0.36.1 || 0.37.0'
   - tsc-alias@1.9.4
   - '@vitest/mocker@5.0.0'
   - '@vitest/spy@5.0.0'