@titanpl/cli 2.0.2 → 2.0.4

package/templates/common/app/t.native.js

@@ -0,0 +1,39 @@
+// titan.js - Named exports for users who prefer imports over the global `t`
+
+export const fetch = t.fetch;
+export const log = t.log;
+export const read = t.read;
+
+// Authentication & Security
+export const jwt = t.jwt;
+export const password = t.password;
+
+// Database
+export const db = t.db;
+
+// File System & Path
+export const fs = t.fs;
+export const path = t.path;
+
+// Crypto & Buffer
+export const crypto = t.crypto;
+export const buffer = t.buffer;
+
+// Storage & Sessions
+export const ls = t.ls;
+export const localStorage = t.localStorage;
+export const session = t.session;
+export const cookies = t.cookies;
+
+// System
+export const os = t.os;
+export const net = t.net;
+export const proc = t.proc;
+
+// Utilities
+export const time = t.time;
+export const url = t.url;
+export const response = t.response;
+export const valid = t.valid;
+
+export const defineAction = (handler) => handler;

package/templates/extension/README.md

@@ -0,0 +1,69 @@
+# Titan Extension Template
+
+This template provides a starting point for building native extensions for Titan.
+
+## Directory Structure
+
+- `index.js`: The JavaScript entry point for your extension. It runs within the Titan runtime.
+- `index.d.ts`: TypeScript definitions for your extension. This ensures users get autocompletion when using your extension.
+- `native/`: (Optional) Rust source code for native high-performance logic.
+- `titan.json`: Configuration file defining your extension's native ABI (if using Rust).
+
+## Type Definitions (`index.d.ts`)
+
+The `index.d.ts` file is crucial for Developer Experience (DX). It allows Titan projects to "see" your extension's API on the global `t` object.
+
+### How it works
+
+Titan uses **Declaration Merging** to extend the global `Titan.Runtime` interface. When a user installs your extension, this file acts as a plugin to their TypeScript environment.
+
+### Customizing Types
+
+Edit `index.d.ts` to match the API you expose in `index.js`.
+
+**Example:**
+
+If your `index.js` looks like this:
+
+```javascript
+// index.js
+t.ext.my_cool_ext = {
+    greet: (name) => `Hello, ${name}!`,
+    compute: (x) => x * 2
+};
+```
+
+Your `index.d.ts` should look like this:
+
+```typescript
+// index.d.ts
+declare global {
+    namespace Titan {
+        interface Runtime {
+            "my-cool-ext": {
+                /**
+                 * Sends a greeting.
+                 */
+                greet(name: string): string;
+
+                /**
+                 * Computes a value.
+                 */
+                compute(x: number): number;
+            }
+        }
+    }
+}
+export { };
+```
+
+## Native Bindings (Rust)
+
+If your extension requires native performance or system access, use the `native/` directory.
+1. Define functions in `native/src/lib.rs`.
+2. Map them in `titan.json`.
+3. Call them from `index.js` using `Titan.native.invoke(...)` (or the helper provided in the template).
+
+---
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/templates/extension/index.d.ts

@@ -0,0 +1,27 @@
+// Type definitions for {{name}}
+// This file facilitates type inference when this extension is installed in a Titan project.
+
+declare global {
+    namespace Titan {
+        interface Runtime {
+            /**
+             * {{name}} Extension
+             */
+            "{{name}}": {
+                /**
+                 * Example hello function
+                 */
+                hello(name: string): string;
+
+                /**
+                 * Example calc function (native wrapper)
+                 */
+                calc(a: number, b: number): number;
+
+                // Add your extension methods here
+            }
+        }
+    }
+}
+
+export { };

package/templates/extension/index.js

@@ -0,0 +1,17 @@
+// Define your extension Key
+if (typeof Titan === "undefined") globalThis.Titan = t;
+const EXT_KEY = "{{name}}";
+
+// Preserve any native functions already attached to this key
+t[EXT_KEY] = Object.assign(t[EXT_KEY] || {}, {
+    // Example pure JavaScript function
+    hello: function (name) {
+        return `Hello ${name} from ${EXT_KEY}!`;
+    },
+
+    // Example Wrapper for Native function
+    calc: function (a, b) {
+        // Assumes the native function 'add' is mapped in titan.json
+        return t[EXT_KEY].add(a, b);
+    }
+});

package/templates/extension/jsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es2021",
+        "checkJs": false,
+        "allowJs": true,
+        "moduleResolution": "node"
+    },
+    "include": [
+        "index.js",
+        "node_modules/titan-sdk/index.d.ts",
+        "node_modules/**/titan-ext.d.ts"
+    ]
+}

package/templates/extension/native/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "{{native_name}}_native"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]

package/templates/extension/native/src/lib.rs

@@ -0,0 +1,5 @@
+
+#[unsafe(no_mangle)]
+pub extern "C" fn add(a: f64, b: f64) -> f64 {
+    a + b
+}