npm - tranfi - Versions diffs - 0.0.1 → 0.1.2 - Mend

tranfi 0.0.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (109) hide show

package/README.md +395 -0
package/app/assets/index-6quYZ5Ap.css +5 -0
package/app/assets/index-pDFMluyz.js +160 -0
package/app/assets/materialdesignicons-webfont-B7mPwVP_.ttf +0 -0
package/app/assets/materialdesignicons-webfont-CSr8KVlo.eot +0 -0
package/app/assets/materialdesignicons-webfont-Dp5v-WZN.woff2 +0 -0
package/app/assets/materialdesignicons-webfont-PXm3-2wK.woff +0 -0
package/app/index.html +13 -0
package/binding.gyp +69 -0
package/csrc/arena.c +91 -0
package/csrc/batch.c +229 -0
package/csrc/buffer.c +78 -0
package/csrc/cJSON.c +3143 -0
package/csrc/cJSON.h +300 -0
package/csrc/codec_csv.c +1058 -0
package/csrc/codec_jsonl.c +374 -0
package/csrc/codec_table.c +218 -0
package/csrc/codec_text.c +229 -0
package/csrc/compiler.c +102 -0
package/csrc/date_utils.h +94 -0
package/csrc/dsl.c +1180 -0
package/csrc/dsl.h +22 -0
package/csrc/expr.c +1245 -0
package/csrc/expr.h +56 -0
package/csrc/internal.h +250 -0
package/csrc/ir.c +119 -0
package/csrc/ir.h +167 -0
package/csrc/ir_schema.c +60 -0
package/csrc/ir_serialize.c +104 -0
package/csrc/ir_sql.c +1211 -0
package/csrc/ir_validate.c +120 -0
package/csrc/main.c +392 -0
package/csrc/op_acf.c +133 -0
package/csrc/op_anomaly.c +120 -0
package/csrc/op_bin.c +109 -0
package/csrc/op_cast.c +195 -0
package/csrc/op_clip.c +88 -0
package/csrc/op_date_trunc.c +181 -0
package/csrc/op_datetime.c +212 -0
package/csrc/op_derive.c +248 -0
package/csrc/op_diff.c +134 -0
package/csrc/op_ewma.c +103 -0
package/csrc/op_explode.c +108 -0
package/csrc/op_fill_down.c +163 -0
package/csrc/op_fill_null.c +123 -0
package/csrc/op_filter.c +132 -0
package/csrc/op_frequency.c +193 -0
package/csrc/op_grep.c +163 -0
package/csrc/op_group_agg.c +285 -0
package/csrc/op_hash.c +126 -0
package/csrc/op_head.c +149 -0
package/csrc/op_interpolate.c +239 -0
package/csrc/op_join.c +384 -0
package/csrc/op_label_encode.c +144 -0
package/csrc/op_lead.c +190 -0
package/csrc/op_normalize.c +226 -0
package/csrc/op_onehot.c +185 -0
package/csrc/op_pivot.c +370 -0
package/csrc/op_registry.c +1148 -0
package/csrc/op_rename.c +138 -0
package/csrc/op_replace.c +202 -0
package/csrc/op_sample.c +101 -0
package/csrc/op_select.c +140 -0
package/csrc/op_skip.c +152 -0
package/csrc/op_sort.c +273 -0
package/csrc/op_split.c +114 -0
package/csrc/op_split_data.c +87 -0
package/csrc/op_stack.c +315 -0
package/csrc/op_stats.c +779 -0
package/csrc/op_step.c +171 -0
package/csrc/op_tail.c +96 -0
package/csrc/op_top.c +150 -0
package/csrc/op_trim.c +109 -0
package/csrc/op_unique.c +300 -0
package/csrc/op_unpivot.c +159 -0
package/csrc/op_validate.c +71 -0
package/csrc/op_window.c +150 -0
package/csrc/pipeline.c +315 -0
package/csrc/plan.c +206 -0
package/csrc/recipes.c +102 -0
package/csrc/recipes.h +27 -0
package/csrc/report.c +463 -0
package/csrc/report.h +22 -0
package/csrc/tranfi.h +123 -0
package/csrc/wasm_api.c +157 -0
package/napi_api.c +326 -0
package/package.json +46 -57
package/src/cli.js +193 -0
package/src/engines/duckdb.js +109 -0
package/src/index.js +306 -0
package/src/native.js +22 -0
package/src/pipeline.js +286 -0
package/src/server.js +277 -0
package/src/wasm.js +19 -0
package/wasm/index.js +244 -0
package/wasm/package.json +1 -0
package/wasm/tranfi_core.js +0 -0
package/LICENSE +0 -21
package/dist/bundle.js +0 -1
package/index.html +0 -18
package/logo.png +0 -0
package/src/app.css +0 -160
package/src/app.js +0 -203
package/src/app.vue +0 -253
package/src/bulma-input.vue +0 -110
package/src/common-inputs.js +0 -28
package/src/main.js +0 -18
package/src/transforms.js +0 -166
package/webpack.config.js +0 -108

package/app/assets/materialdesignicons-webfont-B7mPwVP_.ttf ADDED Viewed

Binary file

package/app/assets/materialdesignicons-webfont-CSr8KVlo.eot ADDED Viewed

Binary file

package/app/assets/materialdesignicons-webfont-Dp5v-WZN.woff2 ADDED Viewed

Binary file

package/app/assets/materialdesignicons-webfont-PXm3-2wK.woff ADDED Viewed

Binary file

package/app/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Tranfi</title>
+  <script type="module" crossorigin src="/assets/index-pDFMluyz.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-6quYZ5Ap.css">
+</head>
+<body>
+  <div id="app"></div>
+</body>
+</html>

package/binding.gyp ADDED Viewed

@@ -0,0 +1,69 @@
+{
+  "targets": [
+    {
+      "target_name": "tranfi_napi",
+      "sources": [
+        "napi_api.c",
+        "csrc/cJSON.c",
+        "csrc/arena.c",
+        "csrc/buffer.c",
+        "csrc/batch.c",
+        "csrc/pipeline.c",
+        "csrc/plan.c",
+        "csrc/expr.c",
+        "csrc/codec_csv.c",
+        "csrc/codec_jsonl.c",
+        "csrc/codec_text.c",
+        "csrc/codec_table.c",
+        "csrc/op_filter.c",
+        "csrc/op_select.c",
+        "csrc/op_rename.c",
+        "csrc/op_head.c",
+        "csrc/op_skip.c",
+        "csrc/op_derive.c",
+        "csrc/op_stats.c",
+        "csrc/op_unique.c",
+        "csrc/op_sort.c",
+        "csrc/op_validate.c",
+        "csrc/op_trim.c",
+        "csrc/op_fill_null.c",
+        "csrc/op_cast.c",
+        "csrc/op_clip.c",
+        "csrc/op_replace.c",
+        "csrc/op_hash.c",
+        "csrc/op_bin.c",
+        "csrc/op_fill_down.c",
+        "csrc/op_step.c",
+        "csrc/op_window.c",
+        "csrc/op_explode.c",
+        "csrc/op_split.c",
+        "csrc/op_unpivot.c",
+        "csrc/op_tail.c",
+        "csrc/op_top.c",
+        "csrc/op_sample.c",
+        "csrc/op_group_agg.c",
+        "csrc/op_frequency.c",
+        "csrc/op_datetime.c",
+        "csrc/op_grep.c",
+        "csrc/op_pivot.c",
+        "csrc/op_join.c",
+        "csrc/op_stack.c",
+        "csrc/op_lead.c",
+        "csrc/op_date_trunc.c",
+        "csrc/ir.c",
+        "csrc/ir_serialize.c",
+        "csrc/ir_sql.c",
+        "csrc/ir_validate.c",
+        "csrc/ir_schema.c",
+        "csrc/op_registry.c",
+        "csrc/compiler.c",
+        "csrc/dsl.c",
+        "csrc/recipes.c"
+      ],
+      "include_dirs": [
+        "csrc"
+      ],
+      "cflags": ["-std=c11", "-Wall", "-D_POSIX_C_SOURCE=200809L"]
+    }
+  ]
+}

package/csrc/arena.c ADDED Viewed

@@ -0,0 +1,91 @@
+/*
+ * arena.c — Simple arena (bump) allocator.
+ * Allocates from fixed-size blocks, grows by adding new blocks.
+ */
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+#define DEFAULT_BLOCK_SIZE (64 * 1024) /* 64 KB */
+#define ALIGN_UP(x, a) (((x) + (a) - 1) & ~((a) - 1))
+static tf_arena_block *block_create(size_t cap) {
+    tf_arena_block *blk = malloc(sizeof(tf_arena_block));
+    if (!blk) return NULL;
+    blk->data = malloc(cap);
+    if (!blk->data) { free(blk); return NULL; }
+    blk->used = 0;
+    blk->cap = cap;
+    blk->next = NULL;
+    return blk;
+}
+static void block_free(tf_arena_block *blk) {
+    while (blk) {
+        tf_arena_block *next = blk->next;
+        free(blk->data);
+        free(blk);
+        blk = next;
+    }
+}
+tf_arena *tf_arena_create(size_t block_size) {
+    if (block_size == 0) block_size = DEFAULT_BLOCK_SIZE;
+    tf_arena *a = malloc(sizeof(tf_arena));
+    if (!a) return NULL;
+    a->block_size = block_size;
+    a->head = block_create(block_size);
+    if (!a->head) { free(a); return NULL; }
+    a->current = a->head;
+    return a;
+}
+void *tf_arena_alloc(tf_arena *a, size_t size) {
+    if (!a || size == 0) return NULL;
+    size = ALIGN_UP(size, 8);
+    /* Try current block */
+    if (a->current->used + size <= a->current->cap) {
+        void *ptr = a->current->data + a->current->used;
+        a->current->used += size;
+        return ptr;
+    }
+    /* Need a new block — at least big enough for this allocation */
+    size_t new_cap = a->block_size;
+    if (new_cap < size) new_cap = size;
+    tf_arena_block *blk = block_create(new_cap);
+    if (!blk) return NULL;
+    a->current->next = blk;
+    a->current = blk;
+    void *ptr = blk->data;
+    blk->used = size;
+    return ptr;
+}
+char *tf_arena_strdup(tf_arena *a, const char *s) {
+    if (!s) return NULL;
+    size_t len = strlen(s) + 1;
+    char *copy = tf_arena_alloc(a, len);
+    if (copy) memcpy(copy, s, len);
+    return copy;
+}
+void tf_arena_reset(tf_arena *a) {
+    if (!a) return;
+    /* Free all blocks except the first, reset the first */
+    if (a->head->next) {
+        block_free(a->head->next);
+        a->head->next = NULL;
+    }
+    a->head->used = 0;
+    a->current = a->head;
+}
+void tf_arena_free(tf_arena *a) {
+    if (!a) return;
+    block_free(a->head);
+    free(a);
+}

package/csrc/batch.c ADDED Viewed

@@ -0,0 +1,229 @@
+/*
+ * batch.c — Columnar batch: typed columns with per-cell null tracking.
+ */
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+static size_t type_size(tf_type t) {
+    switch (t) {
+        case TF_TYPE_BOOL:      return sizeof(uint8_t);
+        case TF_TYPE_INT64:     return sizeof(int64_t);
+        case TF_TYPE_FLOAT64:   return sizeof(double);
+        case TF_TYPE_STRING:    return sizeof(char *);
+        case TF_TYPE_DATE:      return sizeof(int32_t);
+        case TF_TYPE_TIMESTAMP: return sizeof(int64_t);
+        default:                return 0;
+    }
+}
+tf_batch *tf_batch_create(size_t n_cols, size_t capacity) {
+    tf_arena *arena = tf_arena_create(0);
+    if (!arena) return NULL;
+    tf_batch *b = tf_arena_alloc(arena, sizeof(tf_batch));
+    if (!b) { tf_arena_free(arena); return NULL; }
+    b->arena = arena;
+    b->n_cols = n_cols;
+    b->n_rows = 0;
+    b->capacity = capacity;
+    b->col_names = tf_arena_alloc(arena, n_cols * sizeof(char *));
+    b->col_types = tf_arena_alloc(arena, n_cols * sizeof(tf_type));
+    b->columns = tf_arena_alloc(arena, n_cols * sizeof(void *));
+    b->nulls = tf_arena_alloc(arena, n_cols * sizeof(uint8_t *));
+    if (!b->col_names || !b->col_types || !b->columns || !b->nulls) {
+        tf_arena_free(arena);
+        return NULL;
+    }
+    for (size_t i = 0; i < n_cols; i++) {
+        b->col_names[i] = NULL;
+        b->col_types[i] = TF_TYPE_NULL;
+        b->columns[i] = NULL;
+        b->nulls[i] = NULL;
+    }
+    return b;
+}
+int tf_batch_set_schema(tf_batch *b, size_t col, const char *name, tf_type type) {
+    if (col >= b->n_cols) return TF_ERROR;
+    b->col_names[col] = tf_arena_strdup(b->arena, name);
+    b->col_types[col] = type;
+    /* Allocate column storage */
+    size_t sz = type_size(type);
+    if (sz > 0 && b->capacity > 0) {
+        b->columns[col] = tf_arena_alloc(b->arena, sz * b->capacity);
+        b->nulls[col] = tf_arena_alloc(b->arena, b->capacity);
+        if (!b->columns[col] || !b->nulls[col]) return TF_ERROR;
+        memset(b->nulls[col], 1, b->capacity); /* all null by default */
+    }
+    return TF_OK;
+}
+int tf_batch_ensure_capacity(tf_batch *b, size_t min_rows) {
+    if (min_rows <= b->capacity) return TF_OK;
+    /* We need to reallocate columns — but arena doesn't support realloc.
+     * Allocate new larger arrays and copy. */
+    size_t new_cap = b->capacity ? b->capacity : 16;
+    while (new_cap < min_rows) new_cap *= 2;
+    for (size_t i = 0; i < b->n_cols; i++) {
+        size_t sz = type_size(b->col_types[i]);
+        if (sz == 0) continue;
+        void *new_col = tf_arena_alloc(b->arena, sz * new_cap);
+        uint8_t *new_null = tf_arena_alloc(b->arena, new_cap);
+        if (!new_col || !new_null) return TF_ERROR;
+        if (b->columns[i] && b->n_rows > 0) {
+            memcpy(new_col, b->columns[i], sz * b->n_rows);
+            memcpy(new_null, b->nulls[i], b->n_rows);
+        }
+        memset(new_null + b->n_rows, 1, new_cap - b->n_rows);
+        b->columns[i] = new_col;
+        b->nulls[i] = new_null;
+    }
+    b->capacity = new_cap;
+    return TF_OK;
+}
+/* ---- Setters ---- */
+void tf_batch_set_null(tf_batch *b, size_t row, size_t col) {
+    if (row < b->capacity && col < b->n_cols && b->nulls[col])
+        b->nulls[col][row] = 1;
+}
+void tf_batch_set_bool(tf_batch *b, size_t row, size_t col, bool val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_BOOL) {
+        ((uint8_t *)b->columns[col])[row] = val ? 1 : 0;
+        b->nulls[col][row] = 0;
+    }
+}
+void tf_batch_set_int64(tf_batch *b, size_t row, size_t col, int64_t val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_INT64) {
+        ((int64_t *)b->columns[col])[row] = val;
+        b->nulls[col][row] = 0;
+    }
+}
+void tf_batch_set_float64(tf_batch *b, size_t row, size_t col, double val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_FLOAT64) {
+        ((double *)b->columns[col])[row] = val;
+        b->nulls[col][row] = 0;
+    }
+}
+void tf_batch_set_string(tf_batch *b, size_t row, size_t col, const char *val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_STRING) {
+        ((char **)b->columns[col])[row] = tf_arena_strdup(b->arena, val);
+        b->nulls[col][row] = 0;
+    }
+}
+void tf_batch_set_date(tf_batch *b, size_t row, size_t col, int32_t val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_DATE) {
+        ((int32_t *)b->columns[col])[row] = val;
+        b->nulls[col][row] = 0;
+    }
+}
+void tf_batch_set_timestamp(tf_batch *b, size_t row, size_t col, int64_t val) {
+    if (row < b->capacity && col < b->n_cols && b->col_types[col] == TF_TYPE_TIMESTAMP) {
+        ((int64_t *)b->columns[col])[row] = val;
+        b->nulls[col][row] = 0;
+    }
+}
+/* ---- Getters ---- */
+bool tf_batch_is_null(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return true;
+    return b->nulls[col][row] != 0;
+}
+bool tf_batch_get_bool(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return false;
+    return ((uint8_t *)b->columns[col])[row] != 0;
+}
+int64_t tf_batch_get_int64(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return 0;
+    return ((int64_t *)b->columns[col])[row];
+}
+double tf_batch_get_float64(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return 0.0;
+    return ((double *)b->columns[col])[row];
+}
+const char *tf_batch_get_string(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return NULL;
+    return ((char **)b->columns[col])[row];
+}
+int32_t tf_batch_get_date(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return 0;
+    return ((int32_t *)b->columns[col])[row];
+}
+int64_t tf_batch_get_timestamp(const tf_batch *b, size_t row, size_t col) {
+    if (row >= b->n_rows || col >= b->n_cols) return 0;
+    return ((int64_t *)b->columns[col])[row];
+}
+int tf_batch_copy_row(tf_batch *dst, size_t dst_row,
+                      const tf_batch *src, size_t src_row) {
+    if (tf_batch_ensure_capacity(dst, dst_row + 1) != TF_OK) return TF_ERROR;
+    for (size_t c = 0; c < src->n_cols; c++) {
+        if (tf_batch_is_null(src, src_row, c)) {
+            tf_batch_set_null(dst, dst_row, c);
+            continue;
+        }
+        switch (src->col_types[c]) {
+            case TF_TYPE_BOOL:
+                tf_batch_set_bool(dst, dst_row, c, tf_batch_get_bool(src, src_row, c));
+                break;
+            case TF_TYPE_INT64:
+                tf_batch_set_int64(dst, dst_row, c, tf_batch_get_int64(src, src_row, c));
+                break;
+            case TF_TYPE_FLOAT64:
+                tf_batch_set_float64(dst, dst_row, c, tf_batch_get_float64(src, src_row, c));
+                break;
+            case TF_TYPE_STRING:
+                tf_batch_set_string(dst, dst_row, c, tf_batch_get_string(src, src_row, c));
+                break;
+            case TF_TYPE_DATE:
+                tf_batch_set_date(dst, dst_row, c, tf_batch_get_date(src, src_row, c));
+                break;
+            case TF_TYPE_TIMESTAMP:
+                tf_batch_set_timestamp(dst, dst_row, c, tf_batch_get_timestamp(src, src_row, c));
+                break;
+            default:
+                tf_batch_set_null(dst, dst_row, c);
+                break;
+        }
+    }
+    return TF_OK;
+}
+int tf_batch_col_index(const tf_batch *b, const char *name) {
+    for (size_t i = 0; i < b->n_cols; i++) {
+        if (b->col_names[i] && strcmp(b->col_names[i], name) == 0)
+            return (int)i;
+    }
+    return -1;
+}
+void tf_batch_free(tf_batch *b) {
+    if (!b) return;
+    tf_arena *arena = b->arena;
+    tf_arena_free(arena);
+}

package/csrc/buffer.c ADDED Viewed

@@ -0,0 +1,78 @@
+/*
+ * buffer.c — Growable byte buffer for streaming I/O.
+ * Supports write (append), read (consume), and compact operations.
+ */
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+#define INITIAL_CAP 4096
+void tf_buffer_init(tf_buffer *b) {
+    b->data = NULL;
+    b->len = 0;
+    b->cap = 0;
+    b->read_pos = 0;
+}
+static int buffer_ensure(tf_buffer *b, size_t extra) {
+    size_t needed = b->len + extra;
+    if (needed <= b->cap) return TF_OK;
+    size_t new_cap = b->cap ? b->cap : INITIAL_CAP;
+    while (new_cap < needed) new_cap *= 2;
+    uint8_t *new_data = realloc(b->data, new_cap);
+    if (!new_data) return TF_ERROR;
+    b->data = new_data;
+    b->cap = new_cap;
+    return TF_OK;
+}
+int tf_buffer_write(tf_buffer *b, const uint8_t *data, size_t len) {
+    if (len == 0) return TF_OK;
+    if (buffer_ensure(b, len) != TF_OK) return TF_ERROR;
+    memcpy(b->data + b->len, data, len);
+    b->len += len;
+    return TF_OK;
+}
+int tf_buffer_write_str(tf_buffer *b, const char *s) {
+    return tf_buffer_write(b, (const uint8_t *)s, strlen(s));
+}
+size_t tf_buffer_read(tf_buffer *b, uint8_t *out, size_t len) {
+    size_t avail = b->len - b->read_pos;
+    if (len > avail) len = avail;
+    if (len > 0) {
+        memcpy(out, b->data + b->read_pos, len);
+        b->read_pos += len;
+    }
+    /* Auto-compact when all data consumed */
+    if (b->read_pos == b->len) {
+        b->read_pos = 0;
+        b->len = 0;
+    }
+    return len;
+}
+size_t tf_buffer_readable(const tf_buffer *b) {
+    return b->len - b->read_pos;
+}
+void tf_buffer_compact(tf_buffer *b) {
+    if (b->read_pos == 0) return;
+    size_t remaining = b->len - b->read_pos;
+    if (remaining > 0) {
+        memmove(b->data, b->data + b->read_pos, remaining);
+    }
+    b->len = remaining;
+    b->read_pos = 0;
+}
+void tf_buffer_free(tf_buffer *b) {
+    free(b->data);
+    b->data = NULL;
+    b->len = 0;
+    b->cap = 0;
+    b->read_pos = 0;
+}