eser 0.1.3 → 0.8.1

package/commands/codebase/mod.ts

@@ -0,0 +1,411 @@
+// Copyright 2023-present Eser Ozvataf and other contributors. All rights reserved. Apache-2.0 license.
+
+/**
+ * Codebase command group - validation and management tools
+ *
+ * Subcommands:
+ *   check-circular-deps   Detect circular package dependencies
+ *   check-mod-exports     Validate mod.ts exports all files
+ *   check-export-names    Validate export naming conventions
+ *   check-docs            Validate JSDoc documentation
+ *   check-licenses        Validate license headers
+ *   check-package-configs Validate deno.json/package.json consistency
+ *   versions              Manage workspace versions
+ *
+ * @module
+ */
+
+import * as cliParseArgs from "@std/cli/parse-args";
+import * as fmtColors from "@std/fmt/colors";
+import * as standardsRuntime from "@eser/standards/runtime";
+import * as checkCircularDeps from "@eser/codebase/check-circular-deps";
+import * as checkModExports from "@eser/codebase/check-mod-exports";
+import * as checkExportNames from "@eser/codebase/check-export-names";
+import * as checkDocs from "@eser/codebase/check-docs";
+import * as checkLicenses from "@eser/codebase/check-licenses";
+import * as checkPackageConfigs from "@eser/codebase/check-package-configs";
+import * as versions from "@eser/codebase/versions";
+
+type SubcommandDef = {
+  description: string;
+  usage: string;
+  options: Array<{ flag: string; description: string }>;
+  handler: (args: string[], flags: Record<string, unknown>) => Promise<void>;
+};
+
+const showSubcommandHelp = (name: string, def: SubcommandDef): void => {
+  console.log(`eser codebase ${name} - ${def.description}\n`);
+  console.log(`Usage: ${def.usage}\n`);
+  if (def.options.length > 0) {
+    console.log("Options:");
+    for (const opt of def.options) {
+      console.log(`  ${opt.flag.padEnd(20)} ${opt.description}`);
+    }
+  }
+};
+
+const subcommands: Record<string, SubcommandDef> = {
+  "check-circular-deps": {
+    description: "Detect circular package dependencies",
+    usage: "eser codebase check-circular-deps [options]",
+    options: [
+      {
+        flag: "--root <path>",
+        description: "Root directory (default: current)",
+      },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const root = flags["root"] as string | undefined;
+      console.log("Checking for circular dependencies...\n");
+
+      const result = await checkCircularDeps.checkCircularDeps({ root });
+
+      console.log(`Checked ${result.packagesChecked} packages.`);
+
+      if (result.hasCycles) {
+        console.log(
+          fmtColors.red(
+            `\nFound ${result.cycles.length} circular dependencies:\n`,
+          ),
+        );
+        for (const cycle of result.cycles) {
+          console.log(fmtColors.yellow(`  ${cycle.join(" → ")}`));
+        }
+        standardsRuntime.runtime.process.exit(1);
+      } else {
+        console.log(fmtColors.green("\nNo circular dependencies found."));
+      }
+    },
+  },
+
+  "check-mod-exports": {
+    description: "Validate mod.ts exports all public files",
+    usage: "eser codebase check-mod-exports [options]",
+    options: [
+      {
+        flag: "--root <path>",
+        description: "Root directory (default: current)",
+      },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const root = flags["root"] as string | undefined;
+      console.log("Checking mod.ts exports...\n");
+
+      const result = await checkModExports.checkModExports({ root });
+
+      console.log(`Checked ${result.packagesChecked} packages.`);
+
+      if (!result.isComplete) {
+        console.log(
+          fmtColors.red(
+            `\nFound ${result.missingExports.length} missing exports:\n`,
+          ),
+        );
+        for (const missing of result.missingExports) {
+          console.log(
+            fmtColors.yellow(`  ${missing.packageName}: ${missing.file}`),
+          );
+        }
+        standardsRuntime.runtime.process.exit(1);
+      } else {
+        console.log(fmtColors.green("\nAll mod.ts exports are complete."));
+      }
+    },
+  },
+
+  "check-export-names": {
+    description: "Validate export naming conventions",
+    usage: "eser codebase check-export-names [options]",
+    options: [
+      {
+        flag: "--root <path>",
+        description: "Root directory (default: current)",
+      },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const root = flags["root"] as string | undefined;
+      console.log("Checking export naming conventions...\n");
+
+      const result = await checkExportNames.checkExportNames({ root });
+
+      console.log(`Checked ${result.packagesChecked} packages.`);
+
+      if (!result.isValid) {
+        console.log(
+          fmtColors.red(
+            `\nFound ${result.violations.length} naming violations:\n`,
+          ),
+        );
+        for (const violation of result.violations) {
+          console.log(fmtColors.yellow(`  ${violation.packageName}:`));
+          console.log(`    Export: ${violation.exportPath}`);
+          console.log(`    Suggestion: ${violation.suggestion}`);
+        }
+        standardsRuntime.runtime.process.exit(1);
+      } else {
+        console.log(fmtColors.green("\nAll export names follow conventions."));
+      }
+    },
+  },
+
+  "check-docs": {
+    description: "Validate JSDoc documentation",
+    usage: "eser codebase check-docs [options]",
+    options: [
+      {
+        flag: "--root <path>",
+        description: "Root directory (default: current)",
+      },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const root = flags["root"] as string | undefined;
+      console.log("Checking documentation...\n");
+
+      const result = await checkDocs.checkDocs({ root });
+
+      console.log(
+        `Checked ${result.filesChecked} files, ${result.symbolsChecked} symbols.`,
+      );
+
+      if (!result.isValid) {
+        console.log(
+          fmtColors.red(
+            `\nFound ${result.issues.length} documentation issues:\n`,
+          ),
+        );
+
+        // Group by file
+        const byFile = new Map<string, checkDocs.DocIssue[]>();
+        for (const issue of result.issues) {
+          const existing = byFile.get(issue.file) ?? [];
+          existing.push(issue);
+          byFile.set(issue.file, existing);
+        }
+
+        for (const [file, fileIssues] of byFile) {
+          console.log(fmtColors.yellow(`\n${file}:`));
+          for (const issue of fileIssues) {
+            const lineInfo = issue.line !== undefined ? `:${issue.line}` : "";
+            console.log(`  ${issue.symbol}${lineInfo}: ${issue.issue}`);
+          }
+        }
+
+        standardsRuntime.runtime.process.exit(1);
+      } else {
+        console.log(fmtColors.green("\nAll documentation is valid."));
+      }
+    },
+  },
+
+  "check-licenses": {
+    description: "Validate license headers in source files",
+    usage: "eser codebase check-licenses [options]",
+    options: [
+      { flag: "--fix", description: "Auto-fix missing or incorrect headers" },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const fix = flags["fix"] as boolean | undefined;
+      console.log("Validating license headers...\n");
+
+      const result = await checkLicenses.validateLicenses({ fix });
+
+      if (result.issues.length === 0) {
+        console.log(
+          `Checked ${result.checked} files. All licenses are valid.`,
+        );
+        return;
+      }
+
+      if (fix) {
+        for (const issue of result.issues) {
+          if (issue.fixed) {
+            console.log(`Fixed ${issue.issue} header: ${issue.path}`);
+          }
+        }
+        console.log(`Fixed ${result.fixedCount} files.`);
+      } else {
+        for (const issue of result.issues) {
+          console.error(
+            fmtColors.red(
+              `${
+                issue.issue === "missing" ? "Missing" : "Incorrect"
+              } copyright header: ${issue.path}`,
+            ),
+          );
+        }
+        console.log(
+          fmtColors.yellow(
+            `\nCopyright header should be "// Copyright YYYY-present Eser Ozvataf and other contributors. All rights reserved. Apache-2.0 license."`,
+          ),
+        );
+        standardsRuntime.runtime.process.exit(1);
+      }
+    },
+  },
+
+  "check-package-configs": {
+    description: "Validate deno.json and package.json consistency",
+    usage: "eser codebase check-package-configs [options]",
+    options: [
+      {
+        flag: "--root <path>",
+        description: "Root directory (default: current)",
+      },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (_args, flags) => {
+      const root = flags["root"] as string | undefined;
+      console.log("Checking package config consistency...\n");
+
+      const result = await checkPackageConfigs.checkPackageConfigs({ root });
+
+      console.log(`Checked ${result.packagesChecked} packages.`);
+
+      if (!result.isConsistent) {
+        console.log(
+          fmtColors.red(
+            `\nFound ${result.inconsistencies.length} inconsistencies:\n`,
+          ),
+        );
+
+        // Group by package
+        const byPackage = new Map<
+          string,
+          checkPackageConfigs.ConfigInconsistency[]
+        >();
+        for (const inc of result.inconsistencies) {
+          const existing = byPackage.get(inc.packageName) ?? [];
+          existing.push(inc);
+          byPackage.set(inc.packageName, existing);
+        }
+
+        for (const [pkgName, inconsistencies] of byPackage) {
+          console.log(fmtColors.yellow(`${pkgName}:`));
+          for (const inc of inconsistencies) {
+            console.log(fmtColors.red(`  ⚠ ${inc.field} mismatch:`));
+            console.log(`    deno.json:    ${JSON.stringify(inc.denoValue)}`);
+            console.log(
+              `    package.json: ${JSON.stringify(inc.packageValue)}`,
+            );
+          }
+        }
+
+        standardsRuntime.runtime.process.exit(1);
+      } else {
+        console.log(fmtColors.green("\nAll package configs are consistent."));
+      }
+    },
+  },
+
+  versions: {
+    description: "Manage workspace package versions",
+    usage: "eser codebase versions [command] [options]",
+    options: [
+      { flag: "sync", description: "Sync all packages to root version" },
+      { flag: "patch", description: "Bump patch version (0.0.x)" },
+      { flag: "minor", description: "Bump minor version (0.x.0)" },
+      { flag: "major", description: "Bump major version (x.0.0)" },
+      { flag: "--dry-run", description: "Preview changes without applying" },
+      { flag: "-h, --help", description: "Show this help message" },
+    ],
+    handler: async (args, flags) => {
+      const command = args[0] as versions.VersionCommand | undefined;
+      const dryRun = flags["dry-run"] as boolean | undefined;
+
+      if (command === undefined) {
+        const result = await versions.showVersions();
+        console.table(result.packages);
+        return;
+      }
+
+      const validCommands = ["sync", "patch", "minor", "major"];
+      if (!validCommands.includes(command)) {
+        console.error(fmtColors.red(`Invalid command: ${command}`));
+        console.error(
+          "Usage: eser codebase versions [sync|patch|minor|major] [--dry-run]",
+        );
+        standardsRuntime.runtime.process.exit(1);
+      }
+
+      if (command === "sync") {
+        console.log("Syncing all versions...");
+      } else {
+        console.log(`Bumping all versions (${command})...`);
+      }
+
+      const result = await versions.versions(command, { dryRun });
+
+      console.log(`Target version: ${result.targetVersion}`);
+      console.table(result.updates);
+
+      if (result.dryRun) {
+        console.log(
+          fmtColors.cyan(
+            `Dry run - ${result.changedCount} packages would be modified.`,
+          ),
+        );
+      } else {
+        console.log(`Done. Updated ${result.changedCount} packages.`);
+      }
+    },
+  },
+};
+
+const showHelp = (): void => {
+  console.log("eser codebase - Codebase validation tools\n");
+  console.log("Usage: eser codebase <subcommand> [options]\n");
+  console.log("Subcommands:");
+  console.log("  check-circular-deps   Detect circular package dependencies");
+  console.log("  check-mod-exports     Validate mod.ts exports all files");
+  console.log("  check-export-names    Validate export naming conventions");
+  console.log("  check-docs            Validate JSDoc documentation");
+  console.log("  check-licenses        Validate license headers");
+  console.log(
+    "  check-package-configs Validate deno.json/package.json consistency",
+  );
+  console.log("  versions              Manage workspace versions");
+  console.log(
+    "\nRun 'eser codebase <subcommand> --help' for subcommand options.",
+  );
+};
+
+export const codebaseCommand = async (
+  rawArgs: string[],
+  _parentFlags: Record<string, unknown>,
+): Promise<void> => {
+  // Parse all flags (don't use stopEarly so --help is always captured)
+  const parsed = cliParseArgs.parseArgs(rawArgs, {
+    boolean: ["help", "dry-run", "fix"],
+    string: ["root"],
+    alias: { h: "help" },
+  });
+
+  const subcommand = parsed._[0] as string | undefined;
+
+  // Show main help if no subcommand or help without subcommand
+  if (subcommand === undefined) {
+    showHelp();
+    return;
+  }
+
+  const def = subcommands[subcommand];
+  if (def === undefined) {
+    console.error(fmtColors.red(`Unknown subcommand: ${subcommand}`));
+    console.log("");
+    showHelp();
+    standardsRuntime.runtime.process.exit(1);
+  }
+
+  // Show subcommand help if --help flag
+  if (parsed.help) {
+    showSubcommandHelp(subcommand, def);
+    return;
+  }
+
+  await def.handler(parsed._.slice(1) as string[], parsed);
+};

package/deno.json

@@ -0,0 +1,9 @@
+{
+  "name": "@eser/cli",
+  "version": "0.8.1",
+  "exports": "./main.ts",
+  "imports": {
+    "@std/cli": "jsr:@std/cli@^1.0.25",
+    "@std/fmt": "jsr:@std/fmt@^1.0.8"
+  }
+}

package/main.ts

@@ -0,0 +1,78 @@
+// Copyright 2023-present Eser Ozvataf and other contributors. All rights reserved. Apache-2.0 license.
+
+/**
+ * eser - Versatile development CLI
+ *
+ * A multi-purpose command-line tool for development workflows.
+ * Similar in design to `gh` (GitHub CLI) or `wrangler` (Cloudflare).
+ *
+ * Usage:
+ *   deno run -A ./main.ts <command> [subcommand] [options]
+ *   dx jsr:@eser/cli <command> [subcommand] [options]
+ *
+ * Commands:
+ *   codebase    Codebase validation and management tools
+ *
+ * @module
+ */
+
+import * as cliParseArgs from "@std/cli/parse-args";
+import * as standardsRuntime from "@eser/standards/runtime";
+import { codebaseCommand } from "./commands/codebase/mod.ts";
+
+type CommandHandler = (
+  args: string[],
+  flags: Record<string, unknown>,
+) => Promise<void>;
+
+const commands: Record<string, CommandHandler> = {
+  codebase: codebaseCommand,
+};
+
+const showHelp = (): void => {
+  console.log("eser - Versatile development CLI\n");
+  console.log("Usage: eser <command> [subcommand] [options]\n");
+  console.log("Commands:");
+  console.log("  codebase    Codebase validation and management tools");
+  console.log("\nOptions:");
+  console.log("  -h, --help     Show this help message");
+  console.log("  -v, --version  Show version number");
+  console.log("\nRun 'eser <command> --help' for command-specific help.");
+};
+
+const main = async (): Promise<void> => {
+  // @ts-ignore parseArgs doesn't mutate the array, readonly is safe
+  const args = cliParseArgs.parseArgs(standardsRuntime.runtime.process.args, {
+    boolean: ["help", "version"],
+    alias: { h: "help", v: "version" },
+    stopEarly: true, // Stop parsing at first non-option to pass rest to subcommand
+  });
+
+  if (args.version) {
+    console.log("eser 0.8.0");
+    return;
+  }
+
+  const command = args._[0] as string | undefined;
+
+  // Show main help only if no command or help without command
+  if (command === undefined) {
+    showHelp();
+    return;
+  }
+
+  const handler = commands[command];
+  if (handler === undefined) {
+    console.error(`Unknown command: ${command}`);
+    console.log("");
+    showHelp();
+    standardsRuntime.runtime.process.exit(1);
+  }
+
+  // Pass remaining args to command handler
+  await handler(args._.slice(1) as string[], args);
+};
+
+if (import.meta.main) {
+  await main();
+}

package/package.json

@@ -1,37 +1,15 @@
 {
   "name": "eser",
-  "version": "0.1.3",
-  "description": "",
-  "keywords": [
-    "eser",
-    "ozvataf",
-    "eslintconfig"
-  ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.8.1",
+  "type": "module",
+  "exports": "./main.ts",
+  "bin": {
+    "eser": "./main.ts"
   },
-  "author": "Eser Ozvataf",
-  "homepage": "https://eserozvataf.github.io/eser",
-  "bugs": {
-    "url": "https://github.com/eserozvataf/eser/issues",
-    "email": "eser@ozvataf.com"
-  },
-  "license": "Apache-2.0",
-  "contributors": [
-    {
-      "name": "Eser Ozvataf",
-      "email": "eser@ozvataf.com",
-      "url": "http://eser.ozvataf.com/"
-    }
-  ],
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/eserozvataf/eser.git"
-  },
-  "files": [
-    "index.js",
-    ".eslintrc.json",
-    ".csscomb.json"
-  ]
+  "dependencies": {
+    "@eser/codebase": "workspace:*",
+    "@eser/standards": "workspace:*",
+    "@std/cli": "npm:@jsr/std__cli@^1.0.25",
+    "@std/fmt": "npm:@jsr/std__fmt@^1.0.8"
+  }
 }

package/.csscomb.json

@@ -1,333 +0,0 @@
-{
-    "exclude": [
-        ".git/**",
-        "node_modules/**",
-        "bower_components/**"
-    ],
-
-    "remove-empty-rulesets": true,
-    "always-semicolon": true,
-    "color-case": "upper",
-    "block-indent": "    ",
-    "color-shorthand": false,
-    "element-case": "lower",
-    "eof-newline": true,
-    "leading-zero": true,
-    "quotes": "single",
-    "space-before-colon": "",
-    "space-after-colon": " ",
-    "space-before-combinator": " ",
-    "space-after-combinator": " ",
-    "space-between-declarations": "\n",
-    "space-before-opening-brace": " ",
-    "space-after-opening-brace": "\n",
-    "space-after-selector-delimiter": " ",
-    "space-before-selector-delimiter": "",
-    "space-before-closing-brace": "\n",
-    "strip-spaces": true,
-    "tab-size": 4,
-    "unitless-zero": true,
-    "vendor-prefix-align": true,
-    "verbose": true,
-
-    "sort-order": [
-        [
-            "font",
-            "font-family",
-            "font-size",
-            "font-weight",
-            "font-style",
-            "font-variant",
-            "font-size-adjust",
-            "font-stretch",
-            "font-effect",
-            "font-emphasize",
-            "font-emphasize-position",
-            "font-emphasize-style",
-            "font-smooth",
-            "line-height"
-        ],
-        [
-            "position",
-            "z-index",
-            "top",
-            "right",
-            "bottom",
-            "left"
-        ],
-        [
-            "display",
-            "visibility",
-            "float",
-            "clear",
-            "overflow",
-            "overflow-x",
-            "overflow-y",
-            "-ms-overflow-x",
-            "-ms-overflow-y",
-            "clip",
-            "zoom",
-            "flex-direction",
-            "flex-order",
-            "flex-pack",
-            "flex-align"
-        ],
-        [
-            "-webkit-box-sizing",
-            "-moz-box-sizing",
-            "box-sizing",
-            "width",
-            "min-width",
-            "max-width",
-            "height",
-            "min-height",
-            "max-height",
-            "margin",
-            "margin-top",
-            "margin-right",
-            "margin-bottom",
-            "margin-left",
-            "padding",
-            "padding-top",
-            "padding-right",
-            "padding-bottom",
-            "padding-left"
-        ],
-        [
-            "table-layout",
-            "empty-cells",
-            "caption-side",
-            "border-spacing",
-            "border-collapse",
-            "list-style",
-            "list-style-position",
-            "list-style-type",
-            "list-style-image"
-        ],
-        [
-            "content",
-            "quotes",
-            "counter-reset",
-            "counter-increment",
-            "resize",
-            "cursor",
-            "-webkit-user-select",
-            "-moz-user-select",
-            "-ms-user-select",
-            "user-select",
-            "nav-index",
-            "nav-up",
-            "nav-right",
-            "nav-down",
-            "nav-left",
-            "-webkit-transition",
-            "-moz-transition",
-            "-ms-transition",
-            "-o-transition",
-            "transition",
-            "-webkit-transition-delay",
-            "-moz-transition-delay",
-            "-ms-transition-delay",
-            "-o-transition-delay",
-            "transition-delay",
-            "-webkit-transition-timing-function",
-            "-moz-transition-timing-function",
-            "-ms-transition-timing-function",
-            "-o-transition-timing-function",
-            "transition-timing-function",
-            "-webkit-transition-duration",
-            "-moz-transition-duration",
-            "-ms-transition-duration",
-            "-o-transition-duration",
-            "transition-duration",
-            "-webkit-transition-property",
-            "-moz-transition-property",
-            "-ms-transition-property",
-            "-o-transition-property",
-            "transition-property",
-            "-webkit-transform",
-            "-moz-transform",
-            "-ms-transform",
-            "-o-transform",
-            "transform",
-            "-webkit-transform-origin",
-            "-moz-transform-origin",
-            "-ms-transform-origin",
-            "-o-transform-origin",
-            "transform-origin",
-            "-webkit-animation",
-            "-moz-animation",
-            "-ms-animation",
-            "-o-animation",
-            "animation",
-            "-webkit-animation-name",
-            "-moz-animation-name",
-            "-ms-animation-name",
-            "-o-animation-name",
-            "animation-name",
-            "-webkit-animation-duration",
-            "-moz-animation-duration",
-            "-ms-animation-duration",
-            "-o-animation-duration",
-            "animation-duration",
-            "-webkit-animation-play-state",
-            "-moz-animation-play-state",
-            "-ms-animation-play-state",
-            "-o-animation-play-state",
-            "animation-play-state",
-            "-webkit-animation-timing-function",
-            "-moz-animation-timing-function",
-            "-ms-animation-timing-function",
-            "-o-animation-timing-function",
-            "animation-timing-function",
-            "-webkit-animation-delay",
-            "-moz-animation-delay",
-            "-ms-animation-delay",
-            "-o-animation-delay",
-            "animation-delay",
-            "-webkit-animation-iteration-count",
-            "-moz-animation-iteration-count",
-            "-ms-animation-iteration-count",
-            "-o-animation-iteration-count",
-            "animation-iteration-count",
-            "-webkit-animation-direction",
-            "-moz-animation-direction",
-            "-ms-animation-direction",
-            "-o-animation-direction",
-            "animation-direction",
-            "text-align",
-            "-webkit-text-align-last",
-            "-moz-text-align-last",
-            "-ms-text-align-last",
-            "text-align-last",
-            "vertical-align",
-            "white-space",
-            "text-decoration",
-            "text-emphasis",
-            "text-emphasis-color",
-            "text-emphasis-style",
-            "text-emphasis-position",
-            "text-indent",
-            "-ms-text-justify",
-            "text-justify",
-            "letter-spacing",
-            "word-spacing",
-            "-ms-writing-mode",
-            "text-outline",
-            "text-transform",
-            "text-wrap",
-            "text-overflow",
-            "-ms-text-overflow",
-            "text-overflow-ellipsis",
-            "text-overflow-mode",
-            "-ms-word-wrap",
-            "word-wrap",
-            "word-break",
-            "-ms-word-break",
-            "-moz-tab-size",
-            "-o-tab-size",
-            "tab-size",
-            "-webkit-hyphens",
-            "-moz-hyphens",
-            "hyphens",
-            "pointer-events"
-        ],
-        [
-            "opacity",
-            "filter:progid:DXImageTransform.Microsoft.Alpha(Opacity",
-            "-ms-filter:\\'progid:DXImageTransform.Microsoft.Alpha",
-            "-ms-interpolation-mode",
-            "color",
-            "border",
-            "border-width",
-            "border-style",
-            "border-color",
-            "border-top",
-            "border-top-width",
-            "border-top-style",
-            "border-top-color",
-            "border-right",
-            "border-right-width",
-            "border-right-style",
-            "border-right-color",
-            "border-bottom",
-            "border-bottom-width",
-            "border-bottom-style",
-            "border-bottom-color",
-            "border-left",
-            "border-left-width",
-            "border-left-style",
-            "border-left-color",
-            "-webkit-border-radius",
-            "-moz-border-radius",
-            "border-radius",
-            "-webkit-border-top-left-radius",
-            "-moz-border-radius-topleft",
-            "border-top-left-radius",
-            "-webkit-border-top-right-radius",
-            "-moz-border-radius-topright",
-            "border-top-right-radius",
-            "-webkit-border-bottom-right-radius",
-            "-moz-border-radius-bottomright",
-            "border-bottom-right-radius",
-            "-webkit-border-bottom-left-radius",
-            "-moz-border-radius-bottomleft",
-            "border-bottom-left-radius",
-            "-webkit-border-image",
-            "-moz-border-image",
-            "-o-border-image",
-            "border-image",
-            "-webkit-border-image-source",
-            "-moz-border-image-source",
-            "-o-border-image-source",
-            "border-image-source",
-            "-webkit-border-image-slice",
-            "-moz-border-image-slice",
-            "-o-border-image-slice",
-            "border-image-slice",
-            "-webkit-border-image-width",
-            "-moz-border-image-width",
-            "-o-border-image-width",
-            "border-image-width",
-            "-webkit-border-image-outset",
-            "-moz-border-image-outset",
-            "-o-border-image-outset",
-            "border-image-outset",
-            "-webkit-border-image-repeat",
-            "-moz-border-image-repeat",
-            "-o-border-image-repeat",
-            "border-image-repeat",
-            "outline",
-            "outline-width",
-            "outline-style",
-            "outline-color",
-            "outline-offset",
-            "background",
-            "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader",
-            "background-color",
-            "background-image",
-            "background-repeat",
-            "background-attachment",
-            "background-position",
-            "background-position-x",
-            "-ms-background-position-x",
-            "background-position-y",
-            "-ms-background-position-y",
-            "-webkit-background-clip",
-            "-moz-background-clip",
-            "background-clip",
-            "background-origin",
-            "-webkit-background-size",
-            "-moz-background-size",
-            "-o-background-size",
-            "background-size",
-            "box-decoration-break",
-            "-webkit-box-shadow",
-            "-moz-box-shadow",
-            "box-shadow",
-            "filter:progid:DXImageTransform.Microsoft.gradient",
-            "-ms-filter:\\'progid:DXImageTransform.Microsoft.gradient",
-            "text-shadow"
-        ]
-    ]
-}

package/.eslintrc.json

@@ -1,295 +0,0 @@
-{
-    "rules": {
-        "no-console": 0,
-        "complexity": [
-            1,
-            {
-                "maximum": 8
-            }
-        ],
-        "consistent-return": 1,
-        "curly": [
-            2,
-            "all"
-        ],
-        "dot-location": [
-            2,
-            "property"
-        ],
-        "dot-notation": [
-            2,
-            {
-                "allowKeywords": true
-            }
-        ],
-        "eqeqeq": [
-            2,
-            "allow-null"
-        ],
-        "guard-for-in": 1,
-        "no-alert": 1,
-        "no-caller": 2,
-        "no-else-return": 2,
-        "no-eval": 2,
-        "no-extend-native": [
-            2,
-            {
-                "exceptions": [
-                    "Object"
-                ]
-            }
-        ],
-        "no-extra-bind": 1,
-        "no-extra-label": 1,
-        "no-implicit-coercion": 1,
-        "no-implicit-globals": 1,
-        "no-implied-eval": 2,
-        "no-invalid-this": 1,
-        "no-iterator": 1,
-        "no-labels": 1,
-        "no-lone-blocks": 1,
-        "no-loop-func": 1,
-        "no-magic-numbers": 1,
-        "no-multi-spaces": 1,
-        "no-native-reassign": 2,
-        "no-new": 2,
-        "no-new-func": 2,
-        "no-new-wrappers": 2,
-        "no-param-reassign": [
-            1,
-            {
-                "props": false
-            }
-        ],
-        "no-proto": 1,
-        "no-return-assign": 1,
-        "no-self-compare": 1,
-        "no-throw-literal": 1,
-        "no-unused-expressions": [
-            1,
-            {
-                "allowShortCircuit": false,
-                "allowTernary": false
-            }
-        ],
-        "no-useless-call": 1,
-        "no-useless-concat": 1,
-        "no-void": 1,
-        "wrap-iife": [
-            2,
-            "outside"
-        ],
-        "yoda": [
-            2,
-            "never",
-            {
-                "exceptRange": false,
-                "onlyEquality": false
-            }
-        ],
-        "strict": [
-            1,
-            "global"
-        ],
-        "no-catch-shadow": 2,
-        "no-label-var": 2,
-        "no-shadow": [
-            2,
-            {
-                "builtinGlobals": false,
-                "hoist": "all",
-                "allow": []
-            }
-        ],
-        "no-shadow-restricted-names": 2,
-        "no-undef-init": 2,
-        "no-unused-vars": [
-            0,
-            {
-                "vars": "local",
-                "args": "after-used"
-            }
-        ],
-        "no-use-before-define": [
-            2,
-            {
-                "functions": true,
-                "classes": true
-            }
-        ],
-        "no-new-require": 2,
-        "array-bracket-spacing": [
-            2,
-            "always"
-        ],
-        "block-spacing": [
-            2,
-            "always"
-        ],
-        "brace-style": [
-            2,
-            "stroustrup",
-            {
-                "allowSingleLine": true
-            }
-        ],
-        "camelcase": [
-            1,
-            {
-                "properties": "always"
-            }
-        ],
-        "comma-spacing": [
-            2,
-            {
-                "before": false,
-                "after": true
-            }
-        ],
-        "comma-style": [
-            2,
-            "last"
-        ],
-        "computed-property-spacing": [
-            2,
-            "never"
-        ],
-        "consistent-this": [
-            2,
-            "self"
-        ],
-        "eol-last": 2,
-        "indent": [
-            1,
-            4
-        ],
-        "key-spacing": [
-            2,
-            {
-                "beforeColon": false,
-                "afterColon": true,
-                "mode": "strict"
-            }
-        ],
-        "keyword-spacing": [
-            2,
-            {
-                "before": true,
-                "after": true
-            }
-        ],
-        "linebreak-style": [
-            2,
-            "unix"
-        ],
-        "new-parens": 2,
-        "newline-after-var": [
-            1,
-            "always"
-        ],
-        "newline-before-return": 1,
-        "newline-per-chained-call": 1,
-        "no-mixed-spaces-and-tabs": 1,
-        "no-new-object": 2,
-        "no-plusplus": 1,
-        "no-spaced-func": 2,
-        "no-trailing-spaces": [
-            1,
-            {
-                "skipBlankLines": false
-            }
-        ],
-        "no-unneeded-ternary": 1,
-        "no-whitespace-before-property": 1,
-        "object-curly-spacing": [
-            2,
-            "always"
-        ],
-        "operator-linebreak": [
-            2,
-            "after"
-        ],
-        "quote-props": [
-            2,
-            "as-needed",
-            {
-                "keywords": true,
-                "unnecessary": false
-            }
-        ],
-        "quotes": [
-            2,
-            "single"
-        ],
-        "semi": [
-            2,
-            "always"
-        ],
-        "semi-spacing": [
-            2,
-            {
-                "before": false,
-                "after": true
-            }
-        ],
-        "space-before-blocks": [
-            2,
-            {
-                "functions": "always",
-                "keywords": "always",
-                "classes": "always"
-            }
-        ],
-        "space-before-function-paren": [
-            2,
-            {
-                "anonymous": "always",
-                "named": "never"
-            }
-        ],
-        "space-in-parens": [
-            2,
-            "never"
-        ],
-        "space-infix-ops": [
-            2,
-            {
-                "int32Hint": false
-            }
-        ],
-        "space-unary-ops": [
-            2,
-            {
-                "words": true,
-                "nonwords": false
-            }
-        ],
-        "arrow-body-style": [
-            2,
-            "as-needed"
-        ],
-        "arrow-parens": [
-            2,
-            "always"
-        ],
-        "arrow-spacing": [
-            2,
-            {
-                "before": true,
-                "after": true
-            }
-        ],
-        "no-confusing-arrow": [
-            2,
-            {
-                "allowParens": false
-            }
-        ],
-        "no-var": 2,
-        "prefer-const": 1,
-        "prefer-rest-params": 2,
-        "prefer-spread": 2,
-        "prefer-template": 1
-    },
-    "extends": "eslint:recommended"
-}

package/LICENSE

@@ -1,14 +0,0 @@
-
-   Copyright 2013-2016 Eser Ozvataf
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/README.md

@@ -1,57 +0,0 @@
-# eser
-
-[![npm version][npm-image]][npm-url]
-[![npm download][download-image]][npm-url]
-[![dependencies][dep-image]][dep-url]
-[![license][license-image]][license-url]
-
-This repository consists of my own coding standard and guidelines. You can fork and modify it to have yours or use it as it is.
-
-
-### Usage
-
-To Install:   
-`npm install eser`
-
-To validate with ESLint:   
-`eslint --config ./node_modules/eser/.eslintrc.json ./src/`
-
-To validate with CSScomb:   
-`csscomb --lint --config ./node_modules/eser/.csscomb.json ./src/`
-
-
-### Todo List
-
-See [GitHub Issues](https://github.com/eserozvataf/eser/issues).
-
-
-### Requirements
-
-* node.js (https://nodejs.org/)
-* ESLint (http://eslint.org)
-* CSScomb (http://csscomb.com)
-
-
-## License
-
-Apache 2.0, for further details, please see [LICENSE](LICENSE) file
-
-
-## Contributing
-
-See [contributors.md](contributors.md)
-
-It is publicly open for any contribution. Bugfixes, new features and extra modules are welcome.
-
-* To contribute to code: Fork the repo, push your changes to your fork, and submit a pull request.
-* To report a bug: If something does not work, please report it using GitHub issues.
-* To support: [![Donate](https://img.shields.io/gratipay/eserozvataf.svg)](https://gratipay.com/eserozvataf/)
-
-
-[npm-image]: https://img.shields.io/npm/v/eser.svg?style=flat-square
-[npm-url]: https://www.npmjs.com/package/eser
-[download-image]: https://img.shields.io/npm/dt/eser.svg?style=flat-square
-[dep-image]: https://img.shields.io/david/eserozvataf/eser.svg?style=flat-square
-[dep-url]: https://github.com/eserozvataf/eser
-[license-image]: https://img.shields.io/npm/l/eser.svg?style=flat-square
-[license-url]: https://github.com/eserozvataf/eser/blob/master/LICENSE

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./.eslintrc.json');