@tslite/operators 0.2.0

package/dist/index.cjs

@@ -0,0 +1,165 @@
+'use strict';var parser=require('@tslite/parser');var l=n=>{let e=parser.parse(n),t={};for(let r of e.body)r.type==="TSTypeAliasDeclaration"&&r.id?.name&&r.typeAnnotation&&(t[r.id.name]=r.typeAnnotation);return t};var T=`
+type identity<T> = (x: T) => T;
+type always<T> = (value: T) => () => T;
+type tap<T> = {
+  (fn: (x: T) => unknown): (x: T) => T;
+  (fn: (x: T) => unknown, x: T): T;
+};
+`;var u=`
+type prop<T, K extends keyof T> = {
+  (key: K): (obj: T) => T[K];
+  (key: K, obj: T): T[K];
+};
+type path = {
+  (keys: string[]): (obj: unknown) => unknown;
+  (keys: string[], obj: unknown): unknown;
+};
+type propOr<D> = {
+  (def: D, key: string): (obj: unknown) => unknown;
+  (def: D, key: string, obj: unknown): unknown;
+};
+type pathOr<D> = {
+  (def: D, keys: string[]): (obj: unknown) => unknown;
+  (def: D, keys: string[], obj: unknown): unknown;
+};
+/* pick: afrouxado \u2014 a vers\xE3o precisa \`keys: K[]\` sofre com o alargamento de
+   literal em elemento de array-arg (\`["a"]\` \u2192 string[], viola K extends keyof T).
+   Follow-up de checker (preserva\xE7\xE3o de literal em array). Aqui: keys string[],
+   retorno Partial<T> (subconjunto das chaves de T \u2014 honesto e util). */
+type pick<T> = {
+  (keys: string[]): (obj: T) => { [P in keyof T]?: T[P] };
+  (keys: string[], obj: T): { [P in keyof T]?: T[P] };
+};
+type omit<T> = {
+  (keys: string[]): (obj: T) => T;
+  (keys: string[], obj: T): T;
+};
+type assoc<T, V> = {
+  (key: string, value: V): (obj: T) => T;
+  (key: string, value: V, obj: T): T;
+};
+type merge<A, B> = {
+  (a: A): (b: B) => A & B;
+  (a: A, b: B): A & B;
+};
+type keys<T> = (obj: T) => (keyof T)[];
+type values<T> = (obj: T) => T[keyof T][];
+type entries<T> = (obj: T) => [keyof T, T[keyof T]][];
+type fromEntries<V> = (pairs: [string, V][]) => { [k: string]: V };
+type has<T> = {
+  (key: string): (obj: T) => boolean;
+  (key: string, obj: T): boolean;
+};
+type applySpec<S> = {
+  (spec: S): (input: unknown) => { [K in keyof S]: ReturnType<S[K]> };
+  (spec: S, input: unknown): { [K in keyof S]: ReturnType<S[K]> };
+};
+type evolve<T> = {
+  (transforms: { [K in keyof T]?: (value: T[K]) => T[K] }): (obj: T) => T;
+  (transforms: { [K in keyof T]?: (value: T[K]) => T[K] }, obj: T): T;
+};
+`;var c=`
+type map<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => U[];
+  (fn: (item: T) => U, list: T[]): U[];
+};
+type filter<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => T[];
+  (pred: (item: T) => boolean, list: T[]): T[];
+};
+type find<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => T | undefined;
+  (pred: (item: T) => boolean, list: T[]): T | undefined;
+};
+type reduce<T, A> = {
+  (fn: (acc: A, item: T) => A, init: A): (list: T[]) => A;
+  (fn: (acc: A, item: T) => A, init: A, list: T[]): A;
+};
+type pluck<T, K extends keyof T> = {
+  (key: K): (list: T[]) => T[K][];
+  (key: K, list: T[]): T[K][];
+};
+type indexBy<T> = {
+  (fn: (item: T) => string): (list: T[]) => { [k: string]: T };
+  (fn: (item: T) => string, list: T[]): { [k: string]: T };
+};
+type groupBy<T> = {
+  (fn: (item: T) => string): (list: T[]) => { [k: string]: T[] };
+  (fn: (item: T) => string, list: T[]): { [k: string]: T[] };
+};
+type uniqBy<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => T[];
+  (fn: (item: T) => U, list: T[]): T[];
+};
+type sortBy<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => T[];
+  (fn: (item: T) => U, list: T[]): T[];
+};
+type flatten<T> = (list: T[][]) => T[];
+type includes<T> = {
+  (value: T): (list: T[]) => boolean;
+  (value: T, list: T[]): boolean;
+};
+type some<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => boolean;
+  (pred: (item: T) => boolean, list: T[]): boolean;
+};
+type length<T> = (list: T[]) => number;
+type sum = (list: number[]) => number;
+`;var f=`
+type equals<T> = {
+  (a: T): (b: T) => boolean;
+  (a: T, b: T): boolean;
+};
+type propEq = {
+  (key: string, value: unknown): (obj: unknown) => boolean;
+  (key: string, value: unknown, obj: unknown): boolean;
+};
+type whereEq = {
+  (spec: { [k: string]: unknown }): (obj: unknown) => boolean;
+  (spec: { [k: string]: unknown }, obj: unknown): boolean;
+};
+type ifElse<T, R> = {
+  (pred: (x: T) => boolean, onTrue: (x: T) => R, onFalse: (x: T) => R): (value: T) => R;
+  (pred: (x: T) => boolean, onTrue: (x: T) => R, onFalse: (x: T) => R, value: T): R;
+};
+type when<T> = {
+  (pred: (x: T) => boolean, fn: (x: T) => T): (value: T) => T;
+  (pred: (x: T) => boolean, fn: (x: T) => T, value: T): T;
+};
+/* cond: loose \u2014 a infer\xEAncia de T/R atrav\xE9s do tuple-array de fns aninhado n\xE3o
+   aterra (nem no tsc \xE9 trivial). Vanilla: value/result unknown (o switch costuma
+   alimentar string/label; anote o resultado se precisar). */
+type cond = (
+  pairs: [(x: unknown) => boolean, (x: unknown) => unknown][],
+) => (value: unknown) => unknown;
+type defaultTo<T> = {
+  (def: T): (value: T) => T;
+  (def: T, value: T): T;
+};
+type isNil = (value: unknown) => boolean;
+type isEmpty = (value: unknown) => boolean;
+`;var d=`
+type toUpper = (str: string) => string;
+type toLower = (str: string) => string;
+type trim = (str: string) => string;
+type split = {
+  (sep: string): (str: string) => string[];
+  (sep: string, str: string): string[];
+};
+type join = {
+  (sep: string): (list: string[]) => string;
+  (sep: string, list: string[]): string;
+};
+type template = {
+  (tpl: string): (data: unknown) => string;
+  (tpl: string, data: unknown): string;
+};
+`;var g=`
+type toNumber = (value: unknown) => number;
+type asString = (value: unknown) => string;
+type toBoolean = (value: unknown) => boolean;
+type parse = (text: string) => unknown;
+type stringify = (value: unknown) => string;
+`;var m=[T,u,c,f,d,g].join(`
+`),h=l(m);var o=(n,e)=>{let t=r=>r.length>=n?e(...r.slice(0,n)):(...a)=>t([...r,...a]);return (...r)=>t(r)},p=(n,e)=>{if(n===e)return  true;if(n===null||e===null||typeof n!="object"||typeof e!="object")return n===e;if(Array.isArray(n)!==Array.isArray(e))return  false;let r=Object.keys(n),a=Object.keys(e);return r.length!==a.length?false:r.every(y=>p(n[y],e[y]))},s=n=>n==null,x={identity:n=>n,always:n=>()=>n,tap:o(2,(n,e)=>(n(e),e)),prop:o(2,(n,e)=>s(e)?void 0:e[n]),path:o(2,(n,e)=>n.reduce((t,r)=>s(t)?void 0:t[r],e)),propOr:o(3,(n,e,t)=>{let r=s(t)?void 0:t[e];return s(r)?n:r}),pathOr:o(3,(n,e,t)=>{let r=e.reduce((a,y)=>s(a)?void 0:a[y],t);return s(r)?n:r}),pick:o(2,(n,e)=>{let t={};if(!s(e))for(let r of n)r in e&&(t[r]=e[r]);return t}),omit:o(2,(n,e)=>{let t=new Set(n),r={};for(let a in e)t.has(a)||(r[a]=e[a]);return r}),assoc:o(3,(n,e,t)=>({...t,[n]:e})),merge:o(2,(n,e)=>({...n,...e})),keys:n=>Object.keys(n??{}),values:n=>Object.values(n??{}),entries:n=>Object.entries(n??{}),fromEntries:n=>Object.fromEntries(n),has:o(2,(n,e)=>!s(e)&&Object.prototype.hasOwnProperty.call(e,n)),applySpec:o(2,(n,e)=>{let t={};for(let r in n)t[r]=n[r](e);return t}),evolve:o(2,(n,e)=>{let t={...e};for(let r in n)r in t&&(t[r]=n[r](t[r]));return t}),map:o(2,(n,e)=>e.map(t=>n(t))),filter:o(2,(n,e)=>e.filter(t=>n(t))),find:o(2,(n,e)=>e.find(t=>n(t))),reduce:o(3,(n,e,t)=>t.reduce((r,a)=>n(r,a),e)),pluck:o(2,(n,e)=>e.map(t=>s(t)?void 0:t[n])),indexBy:o(2,(n,e)=>{let t={};for(let r of e)t[n(r)]=r;return t}),groupBy:o(2,(n,e)=>{var r;let t={};for(let a of e)(t[r=n(a)]??(t[r]=[])).push(a);return t}),uniqBy:o(2,(n,e)=>{let t=new Set,r=[];for(let a of e){let y=n(a);t.has(y)||(t.add(y),r.push(a));}return r}),sortBy:o(2,(n,e)=>[...e].sort((t,r)=>{let a=n(t),y=n(r);return a<y?-1:a>y?1:0})),flatten:n=>n.reduce((e,t)=>e.concat(t),[]),includes:o(2,(n,e)=>e.some(t=>p(t,n))),some:o(2,(n,e)=>e.some(t=>n(t))),length:n=>n.length,sum:n=>n.reduce((e,t)=>e+t,0),equals:o(2,(n,e)=>p(n,e)),propEq:o(3,(n,e,t)=>!s(t)&&p(t[n],e)),whereEq:o(2,(n,e)=>{for(let t in n)if(s(e)||!p(e[t],n[t]))return  false;return  true}),ifElse:o(4,(n,e,t,r)=>n(r)?e(r):t(r)),when:o(3,(n,e,t)=>n(t)?e(t):t),cond:n=>e=>{for(let[t,r]of n)if(t(e))return r(e)},defaultTo:o(2,(n,e)=>s(e)||typeof e=="number"&&Number.isNaN(e)?n:e),isNil:n=>s(n),isEmpty:n=>s(n)?true:typeof n=="string"||Array.isArray(n)?n.length===0:typeof n=="object"?Object.keys(n).length===0:false,toUpper:n=>n.toUpperCase(),toLower:n=>n.toLowerCase(),trim:n=>n.trim(),split:o(2,(n,e)=>e.split(n)),join:o(2,(n,e)=>e.join(n)),template:o(2,(n,e)=>n.replace(/\{(\w+)\}/g,(t,r)=>{let a=s(e)?void 0:e[r];return s(a)?"":String(a)})),toNumber:n=>Number(n),asString:n=>String(n),toBoolean:n=>!!n,parse:n=>JSON.parse(n),stringify:n=>JSON.stringify(n)};var i=(n,e,t)=>({operator:n,on:e,call:t}),k={length:i("length","value",n=>`length(${n})`),map:i("map","array",(n,e)=>`map(${e[0]??"fn"}, ${n})`),filter:i("filter","array",(n,e)=>`filter(${e[0]??"fn"}, ${n})`),find:i("find","array",(n,e)=>`find(${e[0]??"fn"}, ${n})`),reduce:i("reduce","array",(n,e)=>`reduce(${e[0]??"fn"}, ${e[1]??"init"}, ${n})`),some:i("some","array",(n,e)=>`some(${e[0]??"fn"}, ${n})`),includes:i("includes","value",(n,e)=>`includes(${e[0]??"x"}, ${n})`),flat:i("flatten","array",n=>`flatten(${n})`),join:i("join","array",(n,e)=>`join(${e[0]??'", "'}, ${n})`),trim:i("trim","string",n=>`trim(${n})`),toUpperCase:i("toUpper","string",n=>`toUpper(${n})`),toLowerCase:i("toLower","string",n=>`toLower(${n})`),split:i("split","string",(n,e)=>`split(${e[0]??'","'}, ${n})`),toString:i("asString","value",n=>`asString(${n})`)},b=new Set(["push","pop","shift","unshift","splice","sort","reverse","slice","concat","indexOf","lastIndexOf","forEach","every","flatMap","fill","charAt","charCodeAt","substring","substr","replace","replaceAll","padStart","padEnd","startsWith","endsWith","repeat","at","keys","values","entries","hasOwnProperty","valueOf"]),j=n=>n in k||b.has(n);exports.isKnownProtoMember=j;exports.jsMethodReplacements=k;exports.knownProtoMembersWithoutOperator=b;exports.loadOperators=l;exports.vanilla=h;exports.vanillaRuntime=x;exports.vanillaSource=m;

package/dist/index.d.cts

@@ -0,0 +1,41 @@
+import { Schema } from '@tslite/type-core';
+
+/**
+ * Parseia um bloco de aliases TSL e devolve `Record<name, Schema>` — o `vars`
+ * pronto pro `createEnv`. Cada operador vira um valor com o tipo do corpo do alias.
+ */
+declare const loadOperators: (source: string) => Record<string, Schema>;
+
+/** O fonte TSL completo do tier vanilla (todas as categorias concatenadas). */
+declare const vanillaSource: string;
+/** O `Record<name, Schema>` do vanilla — pronto pra `createEnv(vanilla)`. */
+declare const vanilla: Record<string, Schema>;
+
+type Fn = (...args: any[]) => any;
+declare const vanillaRuntime: Record<string, Fn>;
+
+/** Substituição de um método JS por um operador do vanilla. */
+interface OperatorReplacement {
+    /** o operador do `@tslite/operators` que faz o mesmo. */
+    readonly operator: string;
+    /** o receptor típico do método — só pra compor a mensagem. */
+    readonly on: "array" | "string" | "value";
+    /**
+     * Monta a chamada equivalente em código TSL, dado o RECEPTOR (`arr` em
+     * `arr.map(f)`) e os ARGS do método (`[f]`). Reordena pro estilo FP (dado por
+     * último): `arr.map(f)` → `map(f, arr)`. Placeholders quando o arg falta.
+     */
+    readonly call: (receiver: string, args: readonly string[]) => string;
+}
+/** Método JS (por NOME) → o operador que o substitui. Cresce junto com o vanilla. */
+declare const jsMethodReplacements: Readonly<Record<string, OperatorReplacement>>;
+/**
+ * Métodos de protótipo JS COMUNS que NÃO têm operador 1:1 (mutação / sem
+ * equivalente FP direto). São reconhecidos como "JS-ism" (pra a mensagem
+ * explicativa), mas sem sugestão de operador nem auto-fix.
+ */
+declare const knownProtoMembersWithoutOperator: ReadonlySet<string>;
+/** Todo nome que denuncia "pensei em JS/OO" num acesso de membro que não existe. */
+declare const isKnownProtoMember: (name: string) => boolean;
+
+export { type OperatorReplacement, isKnownProtoMember, jsMethodReplacements, knownProtoMembersWithoutOperator, loadOperators, vanilla, vanillaRuntime, vanillaSource };

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from '@tslite/type-core';
+
+/**
+ * Parseia um bloco de aliases TSL e devolve `Record<name, Schema>` — o `vars`
+ * pronto pro `createEnv`. Cada operador vira um valor com o tipo do corpo do alias.
+ */
+declare const loadOperators: (source: string) => Record<string, Schema>;
+
+/** O fonte TSL completo do tier vanilla (todas as categorias concatenadas). */
+declare const vanillaSource: string;
+/** O `Record<name, Schema>` do vanilla — pronto pra `createEnv(vanilla)`. */
+declare const vanilla: Record<string, Schema>;
+
+type Fn = (...args: any[]) => any;
+declare const vanillaRuntime: Record<string, Fn>;
+
+/** Substituição de um método JS por um operador do vanilla. */
+interface OperatorReplacement {
+    /** o operador do `@tslite/operators` que faz o mesmo. */
+    readonly operator: string;
+    /** o receptor típico do método — só pra compor a mensagem. */
+    readonly on: "array" | "string" | "value";
+    /**
+     * Monta a chamada equivalente em código TSL, dado o RECEPTOR (`arr` em
+     * `arr.map(f)`) e os ARGS do método (`[f]`). Reordena pro estilo FP (dado por
+     * último): `arr.map(f)` → `map(f, arr)`. Placeholders quando o arg falta.
+     */
+    readonly call: (receiver: string, args: readonly string[]) => string;
+}
+/** Método JS (por NOME) → o operador que o substitui. Cresce junto com o vanilla. */
+declare const jsMethodReplacements: Readonly<Record<string, OperatorReplacement>>;
+/**
+ * Métodos de protótipo JS COMUNS que NÃO têm operador 1:1 (mutação / sem
+ * equivalente FP direto). São reconhecidos como "JS-ism" (pra a mensagem
+ * explicativa), mas sem sugestão de operador nem auto-fix.
+ */
+declare const knownProtoMembersWithoutOperator: ReadonlySet<string>;
+/** Todo nome que denuncia "pensei em JS/OO" num acesso de membro que não existe. */
+declare const isKnownProtoMember: (name: string) => boolean;
+
+export { type OperatorReplacement, isKnownProtoMember, jsMethodReplacements, knownProtoMembersWithoutOperator, loadOperators, vanilla, vanillaRuntime, vanillaSource };

package/dist/index.js

@@ -0,0 +1,165 @@
+import {parse}from'@tslite/parser';var l=n=>{let e=parse(n),t={};for(let r of e.body)r.type==="TSTypeAliasDeclaration"&&r.id?.name&&r.typeAnnotation&&(t[r.id.name]=r.typeAnnotation);return t};var T=`
+type identity<T> = (x: T) => T;
+type always<T> = (value: T) => () => T;
+type tap<T> = {
+  (fn: (x: T) => unknown): (x: T) => T;
+  (fn: (x: T) => unknown, x: T): T;
+};
+`;var u=`
+type prop<T, K extends keyof T> = {
+  (key: K): (obj: T) => T[K];
+  (key: K, obj: T): T[K];
+};
+type path = {
+  (keys: string[]): (obj: unknown) => unknown;
+  (keys: string[], obj: unknown): unknown;
+};
+type propOr<D> = {
+  (def: D, key: string): (obj: unknown) => unknown;
+  (def: D, key: string, obj: unknown): unknown;
+};
+type pathOr<D> = {
+  (def: D, keys: string[]): (obj: unknown) => unknown;
+  (def: D, keys: string[], obj: unknown): unknown;
+};
+/* pick: afrouxado \u2014 a vers\xE3o precisa \`keys: K[]\` sofre com o alargamento de
+   literal em elemento de array-arg (\`["a"]\` \u2192 string[], viola K extends keyof T).
+   Follow-up de checker (preserva\xE7\xE3o de literal em array). Aqui: keys string[],
+   retorno Partial<T> (subconjunto das chaves de T \u2014 honesto e util). */
+type pick<T> = {
+  (keys: string[]): (obj: T) => { [P in keyof T]?: T[P] };
+  (keys: string[], obj: T): { [P in keyof T]?: T[P] };
+};
+type omit<T> = {
+  (keys: string[]): (obj: T) => T;
+  (keys: string[], obj: T): T;
+};
+type assoc<T, V> = {
+  (key: string, value: V): (obj: T) => T;
+  (key: string, value: V, obj: T): T;
+};
+type merge<A, B> = {
+  (a: A): (b: B) => A & B;
+  (a: A, b: B): A & B;
+};
+type keys<T> = (obj: T) => (keyof T)[];
+type values<T> = (obj: T) => T[keyof T][];
+type entries<T> = (obj: T) => [keyof T, T[keyof T]][];
+type fromEntries<V> = (pairs: [string, V][]) => { [k: string]: V };
+type has<T> = {
+  (key: string): (obj: T) => boolean;
+  (key: string, obj: T): boolean;
+};
+type applySpec<S> = {
+  (spec: S): (input: unknown) => { [K in keyof S]: ReturnType<S[K]> };
+  (spec: S, input: unknown): { [K in keyof S]: ReturnType<S[K]> };
+};
+type evolve<T> = {
+  (transforms: { [K in keyof T]?: (value: T[K]) => T[K] }): (obj: T) => T;
+  (transforms: { [K in keyof T]?: (value: T[K]) => T[K] }, obj: T): T;
+};
+`;var c=`
+type map<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => U[];
+  (fn: (item: T) => U, list: T[]): U[];
+};
+type filter<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => T[];
+  (pred: (item: T) => boolean, list: T[]): T[];
+};
+type find<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => T | undefined;
+  (pred: (item: T) => boolean, list: T[]): T | undefined;
+};
+type reduce<T, A> = {
+  (fn: (acc: A, item: T) => A, init: A): (list: T[]) => A;
+  (fn: (acc: A, item: T) => A, init: A, list: T[]): A;
+};
+type pluck<T, K extends keyof T> = {
+  (key: K): (list: T[]) => T[K][];
+  (key: K, list: T[]): T[K][];
+};
+type indexBy<T> = {
+  (fn: (item: T) => string): (list: T[]) => { [k: string]: T };
+  (fn: (item: T) => string, list: T[]): { [k: string]: T };
+};
+type groupBy<T> = {
+  (fn: (item: T) => string): (list: T[]) => { [k: string]: T[] };
+  (fn: (item: T) => string, list: T[]): { [k: string]: T[] };
+};
+type uniqBy<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => T[];
+  (fn: (item: T) => U, list: T[]): T[];
+};
+type sortBy<T, U> = {
+  (fn: (item: T) => U): (list: T[]) => T[];
+  (fn: (item: T) => U, list: T[]): T[];
+};
+type flatten<T> = (list: T[][]) => T[];
+type includes<T> = {
+  (value: T): (list: T[]) => boolean;
+  (value: T, list: T[]): boolean;
+};
+type some<T> = {
+  (pred: (item: T) => boolean): (list: T[]) => boolean;
+  (pred: (item: T) => boolean, list: T[]): boolean;
+};
+type length<T> = (list: T[]) => number;
+type sum = (list: number[]) => number;
+`;var f=`
+type equals<T> = {
+  (a: T): (b: T) => boolean;
+  (a: T, b: T): boolean;
+};
+type propEq = {
+  (key: string, value: unknown): (obj: unknown) => boolean;
+  (key: string, value: unknown, obj: unknown): boolean;
+};
+type whereEq = {
+  (spec: { [k: string]: unknown }): (obj: unknown) => boolean;
+  (spec: { [k: string]: unknown }, obj: unknown): boolean;
+};
+type ifElse<T, R> = {
+  (pred: (x: T) => boolean, onTrue: (x: T) => R, onFalse: (x: T) => R): (value: T) => R;
+  (pred: (x: T) => boolean, onTrue: (x: T) => R, onFalse: (x: T) => R, value: T): R;
+};
+type when<T> = {
+  (pred: (x: T) => boolean, fn: (x: T) => T): (value: T) => T;
+  (pred: (x: T) => boolean, fn: (x: T) => T, value: T): T;
+};
+/* cond: loose \u2014 a infer\xEAncia de T/R atrav\xE9s do tuple-array de fns aninhado n\xE3o
+   aterra (nem no tsc \xE9 trivial). Vanilla: value/result unknown (o switch costuma
+   alimentar string/label; anote o resultado se precisar). */
+type cond = (
+  pairs: [(x: unknown) => boolean, (x: unknown) => unknown][],
+) => (value: unknown) => unknown;
+type defaultTo<T> = {
+  (def: T): (value: T) => T;
+  (def: T, value: T): T;
+};
+type isNil = (value: unknown) => boolean;
+type isEmpty = (value: unknown) => boolean;
+`;var d=`
+type toUpper = (str: string) => string;
+type toLower = (str: string) => string;
+type trim = (str: string) => string;
+type split = {
+  (sep: string): (str: string) => string[];
+  (sep: string, str: string): string[];
+};
+type join = {
+  (sep: string): (list: string[]) => string;
+  (sep: string, list: string[]): string;
+};
+type template = {
+  (tpl: string): (data: unknown) => string;
+  (tpl: string, data: unknown): string;
+};
+`;var g=`
+type toNumber = (value: unknown) => number;
+type asString = (value: unknown) => string;
+type toBoolean = (value: unknown) => boolean;
+type parse = (text: string) => unknown;
+type stringify = (value: unknown) => string;
+`;var m=[T,u,c,f,d,g].join(`
+`),h=l(m);var o=(n,e)=>{let t=r=>r.length>=n?e(...r.slice(0,n)):(...a)=>t([...r,...a]);return (...r)=>t(r)},p=(n,e)=>{if(n===e)return  true;if(n===null||e===null||typeof n!="object"||typeof e!="object")return n===e;if(Array.isArray(n)!==Array.isArray(e))return  false;let r=Object.keys(n),a=Object.keys(e);return r.length!==a.length?false:r.every(y=>p(n[y],e[y]))},s=n=>n==null,x={identity:n=>n,always:n=>()=>n,tap:o(2,(n,e)=>(n(e),e)),prop:o(2,(n,e)=>s(e)?void 0:e[n]),path:o(2,(n,e)=>n.reduce((t,r)=>s(t)?void 0:t[r],e)),propOr:o(3,(n,e,t)=>{let r=s(t)?void 0:t[e];return s(r)?n:r}),pathOr:o(3,(n,e,t)=>{let r=e.reduce((a,y)=>s(a)?void 0:a[y],t);return s(r)?n:r}),pick:o(2,(n,e)=>{let t={};if(!s(e))for(let r of n)r in e&&(t[r]=e[r]);return t}),omit:o(2,(n,e)=>{let t=new Set(n),r={};for(let a in e)t.has(a)||(r[a]=e[a]);return r}),assoc:o(3,(n,e,t)=>({...t,[n]:e})),merge:o(2,(n,e)=>({...n,...e})),keys:n=>Object.keys(n??{}),values:n=>Object.values(n??{}),entries:n=>Object.entries(n??{}),fromEntries:n=>Object.fromEntries(n),has:o(2,(n,e)=>!s(e)&&Object.prototype.hasOwnProperty.call(e,n)),applySpec:o(2,(n,e)=>{let t={};for(let r in n)t[r]=n[r](e);return t}),evolve:o(2,(n,e)=>{let t={...e};for(let r in n)r in t&&(t[r]=n[r](t[r]));return t}),map:o(2,(n,e)=>e.map(t=>n(t))),filter:o(2,(n,e)=>e.filter(t=>n(t))),find:o(2,(n,e)=>e.find(t=>n(t))),reduce:o(3,(n,e,t)=>t.reduce((r,a)=>n(r,a),e)),pluck:o(2,(n,e)=>e.map(t=>s(t)?void 0:t[n])),indexBy:o(2,(n,e)=>{let t={};for(let r of e)t[n(r)]=r;return t}),groupBy:o(2,(n,e)=>{var r;let t={};for(let a of e)(t[r=n(a)]??(t[r]=[])).push(a);return t}),uniqBy:o(2,(n,e)=>{let t=new Set,r=[];for(let a of e){let y=n(a);t.has(y)||(t.add(y),r.push(a));}return r}),sortBy:o(2,(n,e)=>[...e].sort((t,r)=>{let a=n(t),y=n(r);return a<y?-1:a>y?1:0})),flatten:n=>n.reduce((e,t)=>e.concat(t),[]),includes:o(2,(n,e)=>e.some(t=>p(t,n))),some:o(2,(n,e)=>e.some(t=>n(t))),length:n=>n.length,sum:n=>n.reduce((e,t)=>e+t,0),equals:o(2,(n,e)=>p(n,e)),propEq:o(3,(n,e,t)=>!s(t)&&p(t[n],e)),whereEq:o(2,(n,e)=>{for(let t in n)if(s(e)||!p(e[t],n[t]))return  false;return  true}),ifElse:o(4,(n,e,t,r)=>n(r)?e(r):t(r)),when:o(3,(n,e,t)=>n(t)?e(t):t),cond:n=>e=>{for(let[t,r]of n)if(t(e))return r(e)},defaultTo:o(2,(n,e)=>s(e)||typeof e=="number"&&Number.isNaN(e)?n:e),isNil:n=>s(n),isEmpty:n=>s(n)?true:typeof n=="string"||Array.isArray(n)?n.length===0:typeof n=="object"?Object.keys(n).length===0:false,toUpper:n=>n.toUpperCase(),toLower:n=>n.toLowerCase(),trim:n=>n.trim(),split:o(2,(n,e)=>e.split(n)),join:o(2,(n,e)=>e.join(n)),template:o(2,(n,e)=>n.replace(/\{(\w+)\}/g,(t,r)=>{let a=s(e)?void 0:e[r];return s(a)?"":String(a)})),toNumber:n=>Number(n),asString:n=>String(n),toBoolean:n=>!!n,parse:n=>JSON.parse(n),stringify:n=>JSON.stringify(n)};var i=(n,e,t)=>({operator:n,on:e,call:t}),k={length:i("length","value",n=>`length(${n})`),map:i("map","array",(n,e)=>`map(${e[0]??"fn"}, ${n})`),filter:i("filter","array",(n,e)=>`filter(${e[0]??"fn"}, ${n})`),find:i("find","array",(n,e)=>`find(${e[0]??"fn"}, ${n})`),reduce:i("reduce","array",(n,e)=>`reduce(${e[0]??"fn"}, ${e[1]??"init"}, ${n})`),some:i("some","array",(n,e)=>`some(${e[0]??"fn"}, ${n})`),includes:i("includes","value",(n,e)=>`includes(${e[0]??"x"}, ${n})`),flat:i("flatten","array",n=>`flatten(${n})`),join:i("join","array",(n,e)=>`join(${e[0]??'", "'}, ${n})`),trim:i("trim","string",n=>`trim(${n})`),toUpperCase:i("toUpper","string",n=>`toUpper(${n})`),toLowerCase:i("toLower","string",n=>`toLower(${n})`),split:i("split","string",(n,e)=>`split(${e[0]??'","'}, ${n})`),toString:i("asString","value",n=>`asString(${n})`)},b=new Set(["push","pop","shift","unshift","splice","sort","reverse","slice","concat","indexOf","lastIndexOf","forEach","every","flatMap","fill","charAt","charCodeAt","substring","substr","replace","replaceAll","padStart","padEnd","startsWith","endsWith","repeat","at","keys","values","entries","hasOwnProperty","valueOf"]),j=n=>n in k||b.has(n);export{j as isKnownProtoMember,k as jsMethodReplacements,b as knownProtoMembersWithoutOperator,l as loadOperators,h as vanilla,x as vanillaRuntime,m as vanillaSource};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@tslite/operators",
+  "version": "0.2.0",
+  "description": "TSLite operators — functional operator signatures as native TSL types, injectable into the checker Env (FP, no OO). The typed stdlib for JSON mappers.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andersondrosa/tslite.git",
+    "directory": "packages/operators"
+  },
+  "keywords": [
+    "operators",
+    "functional",
+    "ramda",
+    "mapper",
+    "etl",
+    "json",
+    "typescript"
+  ],
+  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tslite/type-core": "0.2.0",
+    "@tslite/parser": "0.1.0"
+  },
+  "devDependencies": {
+    "@tslite/interpret": "0.1.0",
+    "@tslite/checker": "0.2.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "lint:fix": "eslint src tests --fix",
+    "clean": "rm -rf dist",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  }
+}