@sideid/id-profanity-filter 0.1.0

package/src/constants/regions/general.ts

@@ -0,0 +1,111 @@
+import { ProfanityWord } from '../../types';
+
+export const general: ProfanityWord[] = [
+  {
+    word: 'anjing',
+    category: 'profanity',
+    region: 'general',
+    severity: 0.7,
+    aliases: ['anjay', 'anjir', 'anying', 'njing', 'anj'],
+    description: 'Mengacu pada hewan anjing, digunakan sebagai umpatan',
+    context: 'Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan',
+  },
+  {
+    word: 'babi',
+    category: 'profanity',
+    region: 'general',
+    severity: 0.6,
+    aliases: ['bab1', 'b4b1'],
+    description: 'Mengacu pada hewan babi, digunakan sebagai umpatan',
+    context: 'Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan',
+  },
+  {
+    word: 'bangsat',
+    category: 'insult',
+    region: 'general',
+    severity: 0.8,
+    aliases: ['bangst', 'bngst', 'bgst'],
+    description:
+      'Secara harfiah berarti kutu busuk, digunakan sebagai umpatan untuk menyebut seseorang yang tidak bermoral',
+    context:
+      'Umpatan kasar untuk menyebut orang yang dianggap jahat atau merugikan',
+  },
+  {
+    word: 'kontol',
+    category: 'sexual',
+    region: 'general',
+    severity: 0.9,
+    aliases: ['kntl', 'k0ntol', 'k0nt0l'],
+    description: 'Kata vulgar yang mengacu pada alat kelamin laki-laki',
+    context: 'Umpatan kasar atau istilah vulgar untuk alat kelamin',
+  },
+  {
+    word: 'memek',
+    category: 'sexual',
+    region: 'general',
+    severity: 0.9,
+    aliases: ['mmk', 'memk'],
+    description: 'Kata vulgar yang mengacu pada alat kelamin perempuan',
+    context: 'Umpatan kasar atau istilah vulgar untuk alat kelamin',
+  },
+  {
+    word: 'bego',
+    category: 'insult',
+    region: 'general',
+    severity: 0.5,
+    aliases: ['bgo', 'begok'],
+    description: 'Kata yang mengacu pada kebodohan seseorang',
+    context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+  },
+  {
+    word: 'tolol',
+    category: 'insult',
+    region: 'general',
+    severity: 0.6,
+    aliases: ['tll', 'tlol'],
+    description: 'Kata yang mengacu pada kebodohan seseorang',
+    context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+  },
+  {
+    word: 'bajingan',
+    category: 'insult',
+    region: 'general',
+    severity: 0.7,
+    aliases: ['bajingn', 'bjgn'],
+    description: 'Kata yang mengacu pada orang jahat atau tidak bermoral',
+    context:
+      'Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral',
+  },
+  {
+    word: 'goblok',
+    category: 'insult',
+    region: 'general',
+    severity: 0.6,
+    aliases: ['gblk', 'goblk'],
+    description: 'Kata yang mengacu pada kebodohan seseorang',
+    context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+  },
+  {
+    word: 'keparat',
+    category: 'insult',
+    region: 'general',
+    severity: 0.7,
+    aliases: ['kprt', 'keprat'],
+    description: 'Kata yang mengacu pada orang jahat atau tidak bermoral',
+    context:
+      'Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral',
+  },
+  {
+    word: 'bacot',
+    category: 'insult',
+    region: 'general',
+    severity: 0.5,
+    aliases: ['bcot', 'bacot2'],
+    description: 'Kata yang mengacu pada orang yang banyak bicara',
+    context: 'Hinaan untuk menyebut orang yang banyak bicara atau cerewet',
+  },
+];
+
+export const generalWords = general.map((item) => item.word);
+
+export default general;

package/src/constants/regions/index.ts

@@ -0,0 +1,62 @@
+// import { general } from './general';
+// import { jawa } from './jawa';
+// import { sunda } from './sunda';
+// import { betawi } from './betawi';
+// import { batak } from './batak';
+// import { minang } from './minang';
+// import { bali } from './bali';
+// import { madura } from './madura';
+// import { bugis } from './bugis';
+// import { aceh } from './aceh';
+// import { ambon } from './ambon';
+// import { papua } from './papua';
+// import { manado } from './manado';
+// import { banjar } from './banjar';
+// import { palembang } from './palembang';
+// import { lampung } from './lampung';
+// import { ntt } from './ntt';
+// import { ntb } from './ntb';
+
+// export {
+//   general,
+//   jawa,
+//   sunda,
+//   betawi,
+//   batak,
+//   minang,
+//   bali,
+//   madura,
+//   bugis,
+//   aceh,
+//   ambon,
+//   papua,
+//   manado,
+//   banjar,
+//   palembang,
+//   lampung,
+//   ntt,
+//   ntb,
+// };
+
+// export const allRegionWords = [
+//   ...general,
+//   ...jawa,
+//   ...sunda,
+//   ...betawi,
+//   ...batak,
+//   ...minang,
+//   ...bali,
+//   ...madura,
+//   ...bugis,
+//   ...aceh,
+//   ...ambon,
+//   ...papua,
+//   ...manado,
+//   ...banjar,
+//   ...palembang,
+//   ...lampung,
+//   ...ntt,
+//   ...ntb,
+// ];
+
+// export default allRegionWords;

package/src/constants/regions/jawa.ts

@@ -0,0 +1,102 @@
+import { ProfanityWord } from '../../types';
+
+export const jawa: ProfanityWord[] = [
+  {
+    word: 'asu',
+    category: 'profanity',
+    region: 'jawa',
+    severity: 0.7,
+    aliases: ['asyu', 'su'],
+    description: 'Secara harfiah berarti anjing dalam Bahasa Jawa',
+    context: 'Umpatan umum dalam Bahasa Jawa untuk menunjukkan kemarahan',
+  },
+  {
+    word: 'jancok',
+    category: 'sexual',
+    region: 'jawa',
+    severity: 0.8,
+    aliases: ['jancuk', 'jncok', 'jancuk', 'jncuk', 'dancok', 'dancuk'],
+    description: 'Kata umpatan kasar dalam Bahasa Jawa',
+    context: 'Umpatan kasar yang umum digunakan di Jawa Timur',
+  },
+  {
+    word: 'cuk',
+    category: 'sexual',
+    region: 'jawa',
+    severity: 0.7,
+    aliases: ['cok', 'cook'],
+    description: 'Singkatan dari jancok/jancuk',
+    context: 'Umpatan singkat yang umum digunakan di Jawa Timur',
+  },
+  {
+    word: 'diancok',
+    category: 'sexual',
+    region: 'jawa',
+    severity: 0.8,
+    aliases: ['diancuk', 'dancok', 'ancok'],
+    description: 'Variasi dari jancok/jancuk',
+    context: 'Umpatan kasar yang umum digunakan di Jawa Timur',
+  },
+  {
+    word: 'matamu',
+    category: 'insult',
+    region: 'jawa',
+    severity: 0.5,
+    aliases: ['mripat mu', 'matane'],
+    description:
+      'Secara harfiah berarti matamu, digunakan sebagai umpatan ringan',
+    context:
+      'Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar',
+  },
+  {
+    word: 'mbokne ancok',
+    category: 'insult',
+    region: 'jawa',
+    severity: 0.8,
+    aliases: ['mbokne', 'mbokneancok'],
+    description: 'Umpatan yang menyinggung ibu seseorang',
+    context: 'Umpatan kasar yang menyinggung orangtua orang lain',
+  },
+  {
+    word: 'pekok',
+    category: 'insult',
+    region: 'jawa',
+    severity: 0.6,
+    aliases: ['pekak', 'pekilk'],
+    description: 'Kata hinaan yang menunjukkan kebodohan',
+    context: 'Hinaan untuk menyebut orang yang dianggap sangat bodoh',
+  },
+  {
+    word: 'sempak',
+    category: 'disgusting',
+    region: 'jawa',
+    severity: 0.5,
+    aliases: ['sempok'],
+    description: 'Mengacu pada pakaian dalam',
+    context: 'Umpatan ringan yang dianggap jorok',
+  },
+  {
+    word: 'taek',
+    category: 'disgusting',
+    region: 'jawa',
+    severity: 0.6,
+    aliases: ['tai', 'tahi', 'telek'],
+    description: 'Secara harfiah berarti kotoran/tinja',
+    context: 'Umpatan untuk menunjukkan sesuatu yang menjijikkan atau buruk',
+  },
+  {
+    word: 'ndhasmu',
+    category: 'insult',
+    region: 'jawa',
+    severity: 0.5,
+    aliases: ['ndas mu', 'dhasmu'],
+    description:
+      'Secara harfiah berarti kepalamu, digunakan sebagai umpatan ringan',
+    context:
+      'Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar',
+  },
+];
+
+export const jawaWords = jawa.map((item) => item.word);
+
+export default jawa;

package/src/constants/regions/sunda.ts

@@ -0,0 +1,35 @@
+import { ProfanityWord } from '../../types';
+
+export const sunda: ProfanityWord[] = [
+  {
+    word: 'bagong',
+    category: 'insult',
+    region: 'sunda',
+    severity: 0.5,
+    aliases: ['bagog'],
+    description: 'Secara harfiah berarti babi hutan, digunakan sebagai hinaan',
+    context: 'Hinaan untuk menyebut orang yang dianggap jorok atau rakus',
+  },
+  {
+    word: 'belegug',
+    category: 'insult',
+    region: 'sunda',
+    severity: 0.5,
+    aliases: ['belecuk', 'beledog'],
+    description: 'Kata yang mengacu pada kebodohan seseorang',
+    context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+  },
+  {
+    word: 'goblog',
+    category: 'insult',
+    region: 'sunda',
+    severity: 0.6,
+    aliases: ['goblok', 'golbok'],
+    description: 'Kata yang mengacu pada kebodohan seseorang',
+    context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+  },
+];
+
+export const sundaWords = sunda.map((item) => item.word);
+
+export default sunda;

package/src/constants/wordList.ts

@@ -0,0 +1,125 @@
+import { ProfanityWord } from '../types';
+
+import { sexual, sexualWords } from './categories/sexual';
+import { insult, insultWords } from './categories/insult';
+// import { profanity, profanityWords } from './categories/profanity';
+// import { slur, slurWords } from './categories/slur';
+// import { drugs, drugsWords } from './categories/drugs';
+// import { disgusting, disgustingWords } from './categories/disgusting';
+// import { blasphemy, blasphemyWords } from './categories/blasphemy';
+
+import { general, generalWords } from './regions/general';
+import { jawa, jawaWords } from './regions/jawa';
+import { sunda, sundaWords } from './regions/sunda';
+import { betawi, betawiWords } from './regions/betawi';
+import { batak, batakWords } from './regions/batak';
+// import { minang, minangWords } from './regions/minang';
+// import { bali, baliWords } from './regions/bali';
+// import { madura, maduraWords } from './regions/madura';
+// import { bugis, bugisWords } from './regions/bugis';
+// import { aceh, acehWords } from './regions/aceh';
+// import { ambon, ambonWords } from './regions/ambon';
+// import { papua, papuaWords } from './regions/papua';
+// import { manado, manadoWords } from './regions/manado';
+// import { banjar, banjarWords } from './regions/banjar';
+// import { palembang, palembangWords } from './regions/palembang';
+// import { lampung, lampungWords } from './regions/lampung';
+// import { ntt, nttWords } from './regions/ntt';
+// import { ntb, ntbWords } from './regions/ntb';
+
+export const wordCategories = {
+  sexual: sexualWords,
+  insult: insultWords,
+  // profanity: profanityWords,
+  // slur: slurWords,
+  // drugs: drugsWords,
+  // disgusting: disgustingWords,
+  // blasphemy: blasphemyWords,
+};
+
+export const wordRegions = {
+  general: generalWords,
+  jawa: jawaWords,
+  sunda: sundaWords,
+  betawi: betawiWords,
+  batak: batakWords,
+  // minang: minangWords,
+  // bali: baliWords,
+  // madura: maduraWords,
+  // bugis: bugisWords,
+  // aceh: acehWords,
+  // ambon: ambonWords,
+  // papua: papuaWords,
+  // manado: manadoWords,
+  // banjar: banjarWords,
+  // palembang: palembangWords,
+  // lampung: lampungWords,
+  // ntt: nttWords,
+  // ntb: ntbWords,
+};
+
+export const wordObjects: ProfanityWord[] = [
+  ...general,
+  ...jawa,
+  ...sunda,
+  ...betawi,
+  ...batak,
+  // ...minang,
+  // ...bali,
+  // ...madura,
+  // ...bugis,
+  // ...aceh,
+  // ...ambon,
+  // ...papua,
+  // ...manado,
+  // ...banjar,
+  // ...palembang,
+  // ...lampung,
+  // ...ntt,
+  // ...ntb,
+];
+
+export const allWords: string[] = wordObjects.map((item) => item.word);
+
+/**
+ * Kata-kata dengan tingkat keparahan tinggi (subset dari semua kata)
+ */
+export const severeWords: string[] = wordObjects
+  .filter((word) => word.severity >= 0.8)
+  .map((item) => item.word);
+
+/**
+ * Mencari kata berdasarkan kategori dan region
+ *
+ * @param category Kategori kata kotor
+ * @param region Daerah asal kata kotor
+ * @returns Array dari kata kotor
+ */
+export function getWordsByFilter(category?: string, region?: string): string[] {
+  return wordObjects
+    .filter((word) => {
+      const matchCategory = category ? word.category === category : true;
+      const matchRegion = region ? word.region === region : true;
+      return matchCategory && matchRegion;
+    })
+    .map((item) => item.word);
+}
+
+/**
+ * Mencari metadata lengkap untuk sebuah kata
+ *
+ * @param word Kata yang dicari
+ * @returns Objek ProfanityWord jika ditemukan, undefined jika tidak
+ */
+export function getWordMetadata(word: string): ProfanityWord | undefined {
+  return wordObjects.find(
+    (item) =>
+      item.word.toLowerCase() === word.toLowerCase() ||
+      (item.aliases &&
+        item.aliases.some(
+          (alias) => alias.toLowerCase() === word.toLowerCase(),
+        )),
+  );
+}
+
+export default allWords;

package/src/core/analyzer.ts

@@ -0,0 +1,204 @@
+import {
+  FilterOptions,
+  AnalysisResult,
+  ProfanityWord,
+  ProfanityCategory,
+  Region,
+} from '../types';
+import {
+  findProfanity,
+  findProfanityWithMetadata,
+  findCategories,
+  findRegions,
+  calculateSeverity,
+} from './matcher';
+
+/**
+ * Menganalisis teks untuk kata kotor
+ *
+ * @param text Teks yang akan dianalisis
+ * @param options Opsi untuk analisis
+ * @return AnalysisResult dengan hasil analisis
+ */
+export function analyze(
+  text: string,
+  options: FilterOptions = {},
+): AnalysisResult {
+  const matches = findProfanity(text, options);
+
+  if (matches.length === 0) {
+    return {
+      hasProfanity: false,
+      matches: [],
+      matchDetails: [],
+      categories: [],
+      regions: [],
+      severityScore: 0,
+    };
+  }
+
+  const matchDetails = findProfanityWithMetadata(text, options);
+  const categories = findCategories(matchDetails);
+  const regions = findRegions(matchDetails);
+  const severityScore = calculateSeverity(matchDetails);
+
+  return {
+    hasProfanity: true,
+    matches,
+    matchDetails,
+    categories,
+    regions,
+    severityScore,
+  };
+}
+
+/**
+ * menganalisis daftar teks dan ringkasan
+ *
+ * @param texts Daftar teks yagn dianalisis
+ * @param options Opsi untuk analisis
+ * @return Objek dengan ringkasan analisis
+ */
+export function batchAnalyze(
+  texts: string[],
+  options: FilterOptions = {},
+): {
+  totalTexts: number;
+  profaneTexts: number;
+  cleanTexts: number;
+  averageSeverity: number;
+  topCategories: ProfanityCategory[];
+  topRegions: Region[];
+  mostFrequentWords: Array<{ word: string; count: number }>;
+} {
+  const results = texts.map((text) => analyze(text, options));
+  const profaneTexts = results.filter((result) => result.hasProfanity).length;
+  const totalSeverity = results.reduce(
+    (sum, result) => sum + result.severityScore,
+    0,
+  );
+  const averageSeverity = profaneTexts > 0 ? totalSeverity / profaneTexts : 0;
+  const allCategories = results.flatMap((result) => result.categories);
+  const categoryCount: Record<string, number> = {};
+
+  allCategories.forEach((category) => {
+    categoryCount[category] = (categoryCount[category] || 0) + 1;
+  });
+
+  const topCategories = Object.entries(categoryCount)
+    .sort((a, b) => b[1] - a[1])
+    .map(([category]) => category as ProfanityCategory);
+
+  const allRegions = results.flatMap((result) => result.regions);
+  const regionCount: Record<string, number> = {};
+
+  allRegions.forEach((region) => {
+    regionCount[region] = (regionCount[region] || 0) + 1;
+  });
+
+  const topRegions = Object.entries(regionCount)
+    .sort((a, b) => b[1] - a[1])
+    .map(([region]) => region as Region);
+
+  const allWords = results.flatMap((result) => result.matches);
+  const wordCount: Record<string, number> = {};
+
+  allWords.forEach((word) => {
+    wordCount[word] = (wordCount[word] || 0) + 1;
+  });
+
+  const mostFrequentWords = Object.entries(wordCount)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([word, count]) => ({ word, count }));
+
+  return {
+    totalTexts: texts.length,
+    profaneTexts,
+    cleanTexts: texts.length - profaneTexts,
+    averageSeverity,
+    topCategories,
+    topRegions,
+    mostFrequentWords,
+  };
+}
+
+/**
+ * Menganalisis per-kalimat untuk melokalisasi kata kotor
+ *
+ * @param text Teks yang akan dianalisis per-kalimat
+ * @param options Opsi untuk analisis
+ * @returns Array hasil analisis per-kalimat
+ */
+export function analyzeBySentence(
+  text: string,
+  options: FilterOptions = {},
+): Array<AnalysisResult & { sentence: string }> {
+  const sentences = text
+    .split(/(?<=[.!?])\s+/)
+    .filter((sentence) => sentence.trim().length > 0);
+
+  return sentences.map((sentence) => {
+    const result = analyze(sentence, options);
+
+    return {
+      ...result,
+      sentence,
+    };
+  });
+}
+
+/**
+ * Menganalisis teks untuk menemukan kata kotor pada konteks tertentu
+ *
+ * @param text Teks yang akan dianalisis
+ * @param context Kata konteks untuk dicari di dekat kata kotor
+ * @param options Opsi untuk analisis
+ * @returns Konteks di dekat kata kotor
+ */
+export function analyzeWithContext(
+  text: string,
+  contextWindowSize: number = 5,
+  options: FilterOptions = {},
+): Array<{
+  word: string;
+  context: string;
+  position: { start: number; end: number };
+}> {
+  const matches = findProfanity(text, options);
+
+  if (matches.length === 0) {
+    return [];
+  }
+
+  const result = [];
+
+  for (const word of matches) {
+    const regex = new RegExp(
+      `((?:\\S+\\s+){0,${contextWindowSize}})(\\b${escapeRegExp(word)}\\b)((?:\\s+\\S+){0,${contextWindowSize}})`,
+      'gi',
+    );
+
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      const beforeContext = match[1] || '';
+      const wordMatch = match[2];
+      const afterContext = match[3] || '';
+
+      result.push({
+        word: wordMatch,
+        context: beforeContext + wordMatch + afterContext,
+        position: {
+          start: match.index,
+          end: match.index + match[0].length,
+        },
+      });
+    }
+  }
+
+  return result;
+}
+
+function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}