typescratch 1.3.0__tar.gz → 1.6.2__tar.gz

{typescratch-1.3.0 → typescratch-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typescratch
-Version: 1.3.0
+Version: 1.6.2
 Summary: A programming language that compiles to Scratch 3 (.sb3) files
 Author: TypeScratch
 License: Apache-2.0
@@ -23,6 +23,7 @@ Classifier: Topic :: Software Development :: Compilers
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: windows-curses>=2.0; sys_platform == "win32"
 Dynamic: license-file
 
 # TypeScratch

{typescratch-1.3.0 → typescratch-1.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "typescratch"
-version = "1.3.0"
+version = "1.6.2"
 description = "A programming language that compiles to Scratch 3 (.sb3) files"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -25,6 +25,11 @@ classifiers = [
     "Topic :: Education",
     "Topic :: Software Development :: Compilers",
 ]
+# On Windows, curses is not built-in, so we need windows-curses.
+# The platform marker ensures pip only installs it on Windows.
+dependencies = [
+    "windows-curses>=2.0; sys_platform == 'win32'",
+]
 
 [project.scripts]
 typescratch = "typescratch.cli:main"
@@ -39,4 +44,4 @@ include = ["typescratch*"]
 exclude = ["tests*"]
 
 [tool.setuptools.package-data]
-typescratch = ["*.svg", "*.wav"]
+typescratch = ["*.svg", "*.wav", "*.txt"]

{typescratch-1.3.0/typescratch_pypi_release/typescratch_src → typescratch-1.6.2/typescratch}/__init__.py

@@ -46,7 +46,7 @@ from .codegen import Codegen
 from .sb3 import write_sb3, write_sb3_bytes
 
 
-__version__ = "1.2.0"
+__version__ = "1.6.2"
 
 
 def compile_source(src: str, filename: str = "<tysh>", debug: bool = False,
@@ -58,6 +58,10 @@ def compile_source(src: str, filename: str = "<tysh>", debug: bool = False,
     If None, defaults to the directory of `filename` (or cwd).
     """
     dbg = Debug(enabled=debug)
+
+    # Preprocess: handle `fuse "file.tysh"` directives
+    src = _preprocess_fuse(src, filename, dbg)
+
     dbg.section("Tokens")
     toks = tokenize(src, filename)
     for t in toks:
@@ -83,6 +87,43 @@ def compile_source(src: str, filename: str = "<tysh>", debug: bool = False,
     return project, assets
 
 
+def _preprocess_fuse(src: str, filename: str, dbg: Debug) -> str:
+    """Handle `fuse "file.tysh"` directives by inlining file contents.
+
+    The fuse directive must be on its own line.  The file path is relative
+    to the directory of the source file.
+    """
+    import re
+    base_dir = os.path.dirname(os.path.abspath(filename)) if filename != "<tysh>" else os.getcwd()
+
+    lines = src.split("\n")
+    result = []
+    for line in lines:
+        stripped = line.strip()
+        # Match: fuse "file.tysh" or fuse 'file.tysh'
+        m = re.match(r'^fuse\s+["\']([^"\']+)["\']\s*$', stripped)
+        if m:
+            fuse_path = m.group(1)
+            if not os.path.isabs(fuse_path):
+                fuse_path = os.path.join(base_dir, fuse_path)
+            if os.path.isfile(fuse_path):
+                dbg.line(f"Fusing: {fuse_path}")
+                with open(fuse_path, "r", encoding="utf-8") as f:
+                    fused_content = f.read()
+                # Recursively process fuse directives in the fused file
+                fused_content = _preprocess_fuse(fused_content, fuse_path, dbg)
+                result.append(f"// === fused from {m.group(1)} ===")
+                result.extend(fused_content.split("\n"))
+                result.append(f"// === end fuse ===")
+            else:
+                from .errors import ForgotOops
+                raise ForgotOops(f'Cannot fuse file "{m.group(1)}" - file not found')
+        else:
+            result.append(line)
+
+    return "\n".join(result)
+
+
 def source(src: str, out: Optional[str] = None, debug: bool = False,
            filename: str = "<tysh>") -> bytes:
     """Compile a TypeScratch source string and return the .sb3 bytes.

{typescratch-1.3.0 → typescratch-1.6.2}/typescratch/ast_nodes.py

@@ -361,3 +361,39 @@ class ListReporterRef:
     method: str     # 'item' | 'length' | 'contains' | 'itemNum' | 'contents'
     args: List[Any]
     line: int = 0
+
+
+@dataclass
+class TernaryExpr:
+    """Ternary expression: [if (cond) true_val else false_val]
+
+    Desugared at codegen time into if/else that sets a temp variable.
+    """
+    cond: Any
+    true_expr: Any
+    false_expr: Any
+    line: int = 0
+
+
+@dataclass
+class SoundImport:
+    """sound name from "path.wav" - imports a sound file."""
+    name: str
+    path: str
+    line: int = 0
+
+
+@dataclass
+class CostumeImport:
+    """costume name from "path.png" - imports a costume file."""
+    name: str
+    path: str
+    line: int = 0
+
+
+@dataclass
+class LocalVarDecl:
+    """private x = value - declares a local variable inside a custom block."""
+    name: str
+    value: Any
+    line: int = 0

{typescratch-1.3.0 → typescratch-1.6.2}/typescratch/blocks.py

@@ -153,25 +153,51 @@ STACK_BLOCKS = {
         "args": [],
     },
     "goToFront": {
+        "opcode": "looks_gotofrontback",
+        "fields": [("FRONT_BACK", "front")],
+    },
+    "goToBack": {
+        "opcode": "looks_gotofrontback",
+        "fields": [("FRONT_BACK", "back")],
+    },
+    "goFront": {
+        "opcode": "looks_gotofrontback",
+        "fields": [("FRONT_BACK", "front")],
+    },
+    "goBack": {
+        "opcode": "looks_gotofrontback",
+        "fields": [("FRONT_BACK", "back")],
+    },
+    "goForwardLayers": {
         "opcode": "looks_goforwardbackwardlayers",
         "fields": [("FRONTBACK", "front")],
-        "args": [("NUM", "number", "args", True)],  # optional - default 1
+        "args": [("NUM", "number", "args")],
     },
-    "goToBack": {
+    "goBackLayers": {
         "opcode": "looks_goforwardbackwardlayers",
         "fields": [("FRONTBACK", "back")],
-        "args": [("NUM", "number", "args", True)],
+        "args": [("NUM", "number", "args")],
     },
-    "goBackLayers": {
+    "goFwdLyrs": {
+        "opcode": "looks_goforwardbackwardlayers",
+        "fields": [("FRONTBACK", "front")],
+        "args": [("NUM", "number", "args")],
+    },
+    "goBwdLyrs": {
         "opcode": "looks_goforwardbackwardlayers",
         "fields": [("FRONTBACK", "back")],
         "args": [("NUM", "number", "args")],
     },
-    "goForwardLayers": {
+    "goFwdLayers": {
         "opcode": "looks_goforwardbackwardlayers",
         "fields": [("FRONTBACK", "front")],
         "args": [("NUM", "number", "args")],
     },
+    "goBwdLayers": {
+        "opcode": "looks_goforwardbackwardlayers",
+        "fields": [("FRONTBACK", "back")],
+        "args": [("NUM", "number", "args")],
+    },
 
     # ---- Sound ----
     "playSound": {
@@ -552,8 +578,23 @@ REPORTERS = {
     # Looks
     "costumeName": {"opcode": "looks_costumename", "returns": "string"},
     "costumeNumber": {"opcode": "looks_costumenumber", "returns": "number"},
+    "costumeNumberName": {
+        "opcode": "looks_costumenumbername",
+        "fields": [("NUMBER_NAME", None)],
+        "returns": "any",
+    },
+    "cstmNumName": {
+        "opcode": "looks_costumenumbername",
+        "fields": [("NUMBER_NAME", None)],
+        "returns": "any",
+    },
     "backdropName": {"opcode": "looks_backdropname", "returns": "string"},
     "backdropNumber": {"opcode": "looks_backdropnumber", "returns": "number"},
+    "backdropNumberName": {
+        "opcode": "looks_backdropnumbername",
+        "fields": [("NUMBER_NAME", None)],
+        "returns": "any",
+    },
     "size": {"opcode": "looks_size", "returns": "number"},
 
     # Sound

typescratch-1.6.2/typescratch/cli.py

@@ -0,0 +1,171 @@
+"""CLI entry point for TypeScratch.
+
+Usage:
+    typescratch build <file.tysh> [--out <out.sb3>] [--debug]
+    typescratch run <file.tysh> [--debug]
+    typescratch ide [file.tysh]
+    typescratch decompile <file.sb3> [--out <file.tysh>]
+    typescratch fmt <file.tysh>
+    typescratch meow
+    typescratch version
+    typescratch help
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import List, Optional
+
+from . import __version__, file as _file
+from .errors import CompileError
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="typescratch",
+        description="Compile .tysh source files to Scratch 3 (.sb3) files.",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_build = sub.add_parser("build", help="Compile a .tysh file to .sb3")
+    p_build.add_argument("source", help="path to .tysh source file")
+    p_build.add_argument("--out", "-o", default=None, help="output .sb3 path")
+    p_build.add_argument("--debug", action="store_true", help="verbose debug output")
+
+    p_run = sub.add_parser("run", help="Alias for build")
+    p_run.add_argument("source")
+    p_run.add_argument("--out", "-o", default=None)
+    p_run.add_argument("--debug", action="store_true")
+
+    p_ide = sub.add_parser("ide", help="Launch the TypeScratch IDE")
+    p_ide.add_argument("source", nargs="?", default=None, help="optional .tysh file to open")
+
+    p_decompile = sub.add_parser("decompile", help="Decompile a .sb3 file to .tysh")
+    p_decompile.add_argument("source", help="path to .sb3 file")
+    p_decompile.add_argument("--out", "-o", default=None, help="output .tysh path")
+
+    p_fmt = sub.add_parser("fmt", help="Format a .tysh file (auto-indent)")
+    p_fmt.add_argument("source", help="path to .tysh file")
+    p_fmt.add_argument("--out", "-o", default=None, help="output path (default: in-place)")
+
+    sub.add_parser("meow", help="Print the Scratch Cat in ASCII art")
+
+    p_install = sub.add_parser("install", help="Install a package from GitHub")
+    p_install.add_argument("repo", help="github user/repo or user/repo@tag")
+
+    p_uninstall = sub.add_parser("uninstall", help="Remove an installed package")
+    p_uninstall.add_argument("name", help="package name")
+
+    sub.add_parser("list", help="List installed packages")
+
+    sub.add_parser("version", help="Print version")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "version":
+        print(f"TypeScratch v{__version__}")
+        return 0
+
+    if args.cmd == "ide":
+        from .ide import run_ide
+        run_ide(args.source)
+        return 0
+
+    if args.cmd == "decompile":
+        from .decompiler import decompile_to_file
+        try:
+            out = decompile_to_file(args.source, args.out)
+            print(f"OK: decompiled to {out}", file=sys.stderr)
+            return 0
+        except Exception as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 1
+
+    if args.cmd == "fmt":
+        return _format_file(args.source, args.out)
+
+    if args.cmd == "meow":
+        return _meow()
+
+    if args.cmd == "install":
+        from .package_manager import install
+        return install(args.repo)
+
+    if args.cmd == "uninstall":
+        from .package_manager import uninstall
+        return uninstall(args.name)
+
+    if args.cmd == "list":
+        from .package_manager import list_packages
+        return list_packages()
+
+    if args.cmd in ("build", "run"):
+        try:
+            out_path = _file(args.source, out=args.out, debug=args.debug)
+            print(f"OK: wrote {out_path}", file=sys.stderr)
+            return 0
+        except CompileError as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 1
+        except FileNotFoundError as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 2
+        except Exception as e:
+            print(f"internal error: {e}", file=sys.stderr)
+            import traceback
+            traceback.print_exc(file=sys.stderr)
+            return 3
+
+    parser.print_help()
+    return 1
+
+
+def _format_file(path: str, out: Optional[str] = None) -> int:
+    """Format a .tysh file with proper indentation."""
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+    except Exception as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+    formatted = []
+    indent = 0
+    for line in lines:
+        stripped = line.strip()
+        # Decrease indent for closing braces
+        if stripped.startswith("}"):
+            indent = max(0, indent - 1)
+        # Add the line with proper indent
+        if stripped:
+            formatted.append("  " * indent + stripped + "\n")
+        else:
+            formatted.append("\n")
+        # Increase indent after opening braces
+        # Count opening and closing braces on this line
+        opens = stripped.count("{") - stripped.count("}")
+        if opens > 0 and not stripped.startswith("}"):
+            indent += opens
+
+    out_path = out or path
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.writelines(formatted)
+    print(f"OK: formatted {path}" + (f" -> {out_path}" if out else " (in-place)"), file=sys.stderr)
+    return 0
+
+
+def _meow() -> int:
+    """Print the Scratch Cat in ASCII art."""
+    import os
+    meow_path = os.path.join(os.path.dirname(__file__), "meow.txt")
+    try:
+        with open(meow_path, "r") as f:
+            print(f.read())
+    except FileNotFoundError:
+        print("Meow! 🐱")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{typescratch-1.3.0 → typescratch-1.6.2}/typescratch/codegen.py

@@ -476,7 +476,7 @@ class Codegen:
                     "rotationCenterY": rcy,
                 })
         else:
-            # Sprite costume
+            # Sprite costume - use img= if specified
             path = target.img
             data, _ignored_md5ext, fmt, rcx, rcy = self._load_asset(path, is_stage=False)
             asset_id = _md5(data)
@@ -491,11 +491,73 @@ class Codegen:
                 "rotationCenterX": rcx,
                 "rotationCenterY": rcy,
             })
+            # Additional costumes from `costume name from "path.png"` imports
+            for cinfo in getattr(target, "_costume_imports", []):
+                cname = cinfo["name"]
+                cpath = cinfo["path"]
+                cdata, _cmd5, cfmt, crcx, crcy = self._load_asset(cpath, is_stage=False)
+                casset_id = _md5(cdata)
+                cmd5ext = f"{casset_id}.{cfmt}"
+                self.assets[cmd5ext] = cdata
+                costumes.append({
+                    "assetId": casset_id,
+                    "name": cname,
+                    "bitmapResolution": 1 if cfmt == "svg" else 2,
+                    "md5ext": cmd5ext,
+                    "dataFormat": cfmt,
+                    "rotationCenterX": crcx,
+                    "rotationCenterY": crcy,
+                })
         return costumes
 
     def gen_sounds(self, target: A.Target) -> List[dict]:
-        # No sound declaration syntax yet - emit an empty list
-        return []
+        """Generate sound assets from `sound name from "path.wav"` imports."""
+        sounds = []
+        for sinfo in getattr(target, "_sound_imports", []):
+            name = sinfo["name"]
+            path = sinfo["path"]
+            full = path
+            if self.asset_root and not os.path.isabs(path):
+                full = os.path.join(self.asset_root, path)
+            if os.path.isfile(full):
+                with open(full, "rb") as f:
+                    data = f.read()
+                # Determine format
+                if full.lower().endswith(".wav"):
+                    fmt = "wav"
+                elif full.lower().endswith(".mp3"):
+                    fmt = "mp3"
+                else:
+                    fmt = "wav"
+                asset_id = _md5(data)
+                md5ext = f"{asset_id}.{fmt}"
+                self.assets[md5ext] = data
+                sounds.append({
+                    "assetId": asset_id,
+                    "name": name,
+                    "dataFormat": fmt,
+                    "format": "",
+                    "rate": 48000,
+                    "sampleCount": 0,
+                    "md5ext": md5ext,
+                })
+            else:
+                # File not found - use silent fallback
+                from . import assets as ASSETS2
+                data = ASSETS2.SILENT_WAV
+                asset_id = _md5(data)
+                md5ext = f"{asset_id}.wav"
+                self.assets[md5ext] = data
+                sounds.append({
+                    "assetId": asset_id,
+                    "name": name,
+                    "dataFormat": "wav",
+                    "format": "",
+                    "rate": 48000,
+                    "sampleCount": 0,
+                    "md5ext": md5ext,
+                })
+        return sounds
 
     def _load_asset(self, path: Optional[str], is_stage: bool) -> Tuple[bytes, str, str, int, int]:
         """Returns (data, md5ext, format, rotationCenterX, rotationCenterY)."""
@@ -676,6 +738,11 @@ class Codegen:
                                          parent_id, stmt.line)
         if isinstance(stmt, A.BlockCall):
             return self.gen_block_call(stmt, parent_id)
+        if isinstance(stmt, A.LocalVarDecl):
+            return self.gen_var_assign(
+                A.VarAssign(name=stmt.name, value=stmt.value, line=stmt.line),
+                parent_id
+            )
         raise CompileError(f"unknown statement type: {type(stmt).__name__}", stmt.line)
 
     def gen_simple_stack(self, opcode: str, inputs_spec, parent_id, line) -> Tuple[str, str]:
@@ -1485,6 +1552,8 @@ class Codegen:
             return None, block_id
         if isinstance(expr, A.ListReporterRef):
             return self._gen_list_reporter(expr)
+        if isinstance(expr, A.TernaryExpr):
+            return self._gen_ternary(expr)
         if isinstance(expr, A.BuiltinRef):
             # Builtin reporter (e.g. answer, mouseX)
             spec = B.REPORTERS.get(expr.name)
@@ -1544,6 +1613,63 @@ class Codegen:
         # default: string literal
         return A.StringLit(value=name, line=ref.line)
 
+    def _gen_ternary(self, expr: A.TernaryExpr) -> Tuple[Optional[list], Optional[str]]:
+        """Generate a ternary expression [if (cond) x else y].
+
+        This is desugared into: a temp variable, set by an if/else.
+        We create the if/else blocks inline and return a VarRef to the temp.
+        """
+        # Create a temp variable
+        tmp_name = f"_ternary_{gen_id()[:8]}"
+        self._declare_var(tmp_name, 0)
+        vid = self.current_vars[tmp_name]
+
+        # Coerce the condition
+        cond = self._coerce_condition(expr.cond)
+        shadow_cond, sub_cond = self.gen_input_value(cond, "boolean")
+        cond_input = self._pack_input("boolean", shadow_cond, sub_cond)
+
+        # Generate the true branch: set tmp = true_expr
+        true_shadow, true_sub = self.gen_input_value(expr.true_expr, "any")
+        true_block_id = gen_id()
+        self.current_blocks[true_block_id] = {
+            "opcode": "data_setvariableto",
+            "next": None, "parent": None,
+            "inputs": {"VALUE": self._pack_input("any", true_shadow, true_sub)},
+            "fields": {"VARIABLE": [tmp_name, vid]},
+            "shadow": False, "topLevel": False,
+        }
+
+        # Generate the false branch: set tmp = false_expr
+        false_shadow, false_sub = self.gen_input_value(expr.false_expr, "any")
+        false_block_id = gen_id()
+        self.current_blocks[false_block_id] = {
+            "opcode": "data_setvariableto",
+            "next": None, "parent": None,
+            "inputs": {"VALUE": self._pack_input("any", false_shadow, false_sub)},
+            "fields": {"VARIABLE": [tmp_name, vid]},
+            "shadow": False, "topLevel": False,
+        }
+
+        # Generate the if/else block
+        if_block_id = gen_id()
+        self.current_blocks[if_block_id] = {
+            "opcode": "control_if_else",
+            "next": None, "parent": None,
+            "inputs": {
+                "CONDITION": cond_input,
+                "SUBSTACK": [2, true_block_id],
+                "SUBSTACK2": [2, false_block_id],
+            },
+            "fields": {},
+            "shadow": False, "topLevel": False,
+        }
+        self.current_blocks[true_block_id]["parent"] = if_block_id
+        self.current_blocks[false_block_id]["parent"] = if_block_id
+
+        # Return a variable reference to the temp
+        return [SHADOW_VAR, tmp_name, vid], None
+
     def _gen_list_reporter(self, expr: A.ListReporterRef) -> Tuple[Optional[list], Optional[str]]:
         """Generate a list reporter block (data_itemoflist, data_lengthoflist,
         data_listcontainsitem, data_itemnumoflist, data_listcontents).